class TestMustBeAddonAuthorizerDecorator(AuthAppTestCase):
def setUp(self):
super(TestMustBeAddonAuthorizerDecorator, self).setUp()
self.project = ProjectFactory()
self.decorated = must_be_addon_authorizer('github')(needs_addon_view)
@mock.patch('website.project.decorators._kwargs_to_nodes')
@mock.patch('framework.auth.decorators.Auth.from_kwargs')
def test_must_be_authorizer_true(self, mock_get_current_user, mock_kwargs_to_nodes):
# Mock
mock_get_current_user.return_value = Auth(self.project.creator)
mock_kwargs_to_nodes.return_value = (None, self.project)
# Setup
self.project.add_addon('github', auth=None)
node_settings = self.project.get_addon('github')
self.project.creator.add_addon('github')
user_settings = self.project.creator.get_addon('github')
node_settings.user_settings = user_settings
node_settings.save()
# Test
res = self.decorated()
assert_equal(res, 'openaddon')
def test_must_be_authorizer_false(self):
# Setup
self.project.add_addon('github', auth=None)
node_settings = self.project.get_addon('github')
user2 = UserFactory()
user2.add_addon('github')
user_settings = user2.get_addon('github')
node_settings.user_settings = user_settings
node_settings.save()
# Test
with assert_raises(HTTPError):
self.decorated()
def test_must_be_authorizer_no_user_settings(self):
self.project.add_addon('github', auth=None)
with assert_raises(HTTPError):
self.decorated()
def test_must_be_authorizer_no_node_settings(self):
with assert_raises(HTTPError):
self.decorated()
class TestCreateBucket(OsfTestCase):
def setUp(self):
super(TestCreateBucket, self).setUp()
self.user = AuthUserFactory()
self.consolidated_auth = Auth(user=self.user)
self.auth = ('test', self.user.api_keys[0]._primary_key)
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('s3', auth=self.consolidated_auth)
self.project.creator.add_addon('s3')
self.user_settings = self.user.get_addon('s3')
self.user_settings.access_key = 'We-Will-Rock-You'
self.user_settings.secret_key = 'Idontknowanyqueensongs'
self.user_settings.save()
self.node_settings = self.project.get_addon('s3')
self.node_settings.bucket = 'Sheer-Heart-Attack'
self.node_settings.user_settings = self.project.creator.get_addon('s3')
self.node_settings.save()
def test_bad_names(self):
assert_false(validate_bucket_name('bogus naMe'))
assert_false(validate_bucket_name(''))
assert_false(validate_bucket_name('no'))
assert_false(validate_bucket_name('.cantstartwithp'))
assert_false(validate_bucket_name('or.endwith.'))
assert_false(validate_bucket_name('..nodoubles'))
assert_false(validate_bucket_name('no_unders_in'))
def test_names(self):
assert_true(validate_bucket_name('imagoodname'))
assert_true(validate_bucket_name('still.passing'))
assert_true(validate_bucket_name('can-have-dashes'))
assert_true(validate_bucket_name('kinda.name.spaced'))
@mock.patch('website.addons.s3.views.crud.create_bucket')
@mock.patch('website.addons.s3.utils.get_bucket_drop_down')
def test_create_bucket_pass(self, mock_make, mock_dropdown):
mock_make.return_value = True
mock_dropdown.return_value = ['mybucket']
url = self.project.api_url_for('create_new_bucket')
ret = self.app.post_json(url, {'bucket_name': 'doesntevenmatter'}, auth=self.user.auth)
assert_equals(ret.status_int, http.OK)
@mock.patch('website.addons.s3.views.crud.create_bucket')
def test_create_bucket_fail(self, mock_make):
error = S3ResponseError(418, 'because Im a test')
error.message = 'This should work'
mock_make.side_effect = error
url = "/api/v1/project/{0}/s3/newbucket/".format(self.project._id)
ret = self.app.post_json(url, {'bucket_name': 'doesntevenmatter'}, auth=self.user.auth, expect_errors=True)
assert_equals(ret.body, '{"message": "This should work", "title": "Problem connecting to S3"}')
class TestHookMigration(OsfTestCase):
def setUp(self):
super(TestHookMigration, self).setUp()
self.project = ProjectFactory()
self.project.creator.add_addon('github')
self.user_addon = self.project.creator.get_addon('github')
self.project.add_addon('github', None)
self.node_addon = self.project.get_addon('github')
self.node_addon.hook_id = 1
self.node_addon.user_settings = self.user_addon
self.node_addon.save()
@mock.patch('addons.github.utils.make_hook_secret')
@mock.patch('addons.github.api.GitHub.repo')
def test_update_hook(self, mock_repo, mock_make_secret):
mock_make_secret.return_value = 'shh'
update_hook(self.node_addon)
self.node_addon.reload()
assert_equal(self.node_addon.hook_secret, 'shh')
def test_get_targets(self):
AddonGitHubNodeSettings.remove()
addons = [
AddonGitHubNodeSettings(),
AddonGitHubNodeSettings(hook_id=1),
AddonGitHubNodeSettings(user_settings=self.user_addon),
AddonGitHubNodeSettings(hook_id=1, user_settings=self.user_addon),
]
for addon in addons:
addon.save()
targets = get_targets()
assert_equal(targets.count(), 1)
assert_equal(targets[0]._id, addons[-1]._id)
def test_migration(self):
BoxUserSettings.remove()
user = UserFactory()
node = ProjectFactory(creator=user)
account = BoxAccountFactory()
user.external_accounts = [account]
user.add_addon('box', auth=Auth(user))
user_addon = user.get_addon('box')
user_addon.save()
node.add_addon('box', auth=Auth(user))
node_addon = node.get_addon('box')
node_addon.foreign_user_settings = user_addon
node_addon.folder_id = 'abcdef0'
node_addon.folder_path = '/'
node_addon.folder_name = '/ (Full Box)'
node_addon.save()
assert_equal(node_addon.external_account, None)
assert_equal(node_addon.folder_id, 'abcdef0')
do_migration()
node_addon.reload()
assert_equal(node_addon.external_account, account)
assert_equal(node_addon.folder_id, 'abcdef0')
assert_equal(node_addon.folder_path, '/')
assert_equal(node_addon.folder_name, '/ (Full Box)')
class TestGoogleDriveHgridViews(OsfTestCase):
def setUp(self):
super(TestGoogleDriveHgridViews, self).setUp()
self.user = AuthUserFactory()
self.user.add_addon('googledrive')
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('googledrive', Auth(self.user))
self.node_settings = self.project.get_addon('googledrive')
self.user_settings = self.user.get_addon('googledrive')
self.node_settings.user_settings = self.user_settings
self.user_settings.save()
self.node_settings.save()
# Log user in
self.app.authenticate(*self.user.auth)
@mock.patch('website.addons.googledrive.views.hgrid.GoogleDriveClient.folders')
def test_googledrive_folders(self, mock_drive_client_folders):
folderId = '12345'
mock_drive_client_folders.return_value = mock_folders['items']
url = api_url_for('googledrive_folders', pid=self.project._primary_key, folderId=folderId)
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.status_code, 200)
assert_equal(len(res.json), len(mock_folders['items']))
@mock.patch('website.addons.googledrive.views.hgrid.GoogleDriveClient.about')
def test_googledrive_folders_returns_only_root(self, mock_about):
mock_about.return_value = {'rootFolderId': '24601'}
url = self.project.api_url_for('googledrive_folders')
res = self.app.get(url, auth=self.user.auth)
assert_equal(len(res.json), 1)
assert_equal(res.status_code, 200)
assert_equal(res.json[0]['id'], '24601')
def test_oauth_callback_with_node(self, mock_get_token, mock_github_user):
mock_get_token.return_value = {
"access_token": "testing access token",
"token_type": "testing token type",
"scope": ["repo"]
}
user = mock.Mock()
user.id = "testing user id"
user.login = "******"
mock_github_user.return_value = user
project = ProjectFactory(creator=self.user)
project.add_addon('github', auth=Auth(user=self.user))
project.save()
url = api_url_for('github_oauth_callback', uid=self.user._id, nid=project._id)
res = self.app.get(url, {"code": "12345"}, auth=self.user.auth)
self.user_settings.reload()
node_settings = project.get_addon('github')
node_settings.reload()
assert_true(res.status_code, 302)
assert_not_in("/settings/addons/", res.location)
assert_in("/settings", res.location)
assert_true(self.user_settings.oauth_settings)
assert_equal(self.user_settings.oauth_access_token, "testing access token")
assert_equal(self.user_settings.oauth_token_type, "testing token type")
assert_equal(self.user_settings.github_user_name, "testing user")
assert_equal(self.user_settings.oauth_settings.github_user_id, "testing user id")
assert_equal(node_settings.user_settings, self.user_settings)
class TestDatasetMigration(OsfTestCase):
def setUp(self):
super(TestDatasetMigration, self).setUp()
self.project = ProjectFactory()
self.project.creator.add_addon('dataverse')
self.user_addon = self.project.creator.get_addon('dataverse')
self.project.add_addon('dataverse', None)
self.node_addon = self.project.get_addon('dataverse')
self.node_addon.study_hdl = 'doi:12.3456/DVN/00003'
self.node_addon.study = 'Example (DVN/00003)'
self.node_addon.user_settings = self.user_addon
self.node_addon.save()
def test_migration(self):
do_migration([self.node_addon], dry=False)
self.node_addon.reload()
assert_equal(self.node_addon.dataset_doi, 'doi:12.3456/DVN/00003')
assert_equal(self.node_addon.dataset, 'Example (DVN/00003)')
def test_get_targets(self):
AddonDataverseNodeSettings.remove()
addons = [
AddonDataverseNodeSettings(),
AddonDataverseNodeSettings(study_hdl='foo'),
AddonDataverseNodeSettings(user_settings=self.user_addon),
AddonDataverseNodeSettings(study_hdl='foo', user_settings=self.user_addon),
]
for addon in addons:
addon.save()
targets = get_targets()
assert_equal(targets.count(), 1)
assert_equal(targets[0]._id, addons[-1]._id)
class TestViewsAuth(OsfTestCase):
def setUp(self):
super(TestViewsAuth, self).setUp()
self.user = AuthUserFactory()
self.consolidated_auth = Auth(user=self.user)
self.auth = ('test', self.user.api_keys[0]._primary_key)
self.project = ProjectFactory(creator=self.user)
self.non_authenticator = AuthUserFactory()
self.project.add_contributor(
contributor=self.non_authenticator,
auth=Auth(self.project.creator),
)
self.project.add_addon('figshare', auth=self.consolidated_auth)
self.project.creator.add_addon('figshare')
self.node_settings = self.project.get_addon('figshare')
self.user_settings = self.project.creator.get_addon('figshare')
self.node_settings.user_settings = self.user_settings
self.node_settings.figshare_id = '436'
self.node_settings.figshare_type = 'project'
self.node_settings.save()
@unittest.skip('finish this')
def test_oauth_fail(self):
url = '/api/v1/project/{0}/figshare/oauth/'.format(self.project._id)
self.app.get(url, auth=self.user.auth)
@unittest.skip('finish this')
def test_oauth_bad_token(self):
pass
class TestAssertion(OsfTestCase):
def setUp(self):
super(TestAssertion, self).setUp()
self.user = AuthUserFactory()
self.user.add_addon('badges', override=True)
self.usersettings = self.user.get_addon('badges', self.user.auth)
self.usersettings.save()
self.project = ProjectFactory()
self.node_settings = self.project.get_addon('badges')
create_mock_badge(self.usersettings)
self.badge = self.usersettings.badges[0]
def test_parent(self):
assertion = BadgeAssertion.create(self.badge, self.project)
assert_equals(assertion.badge, self.badge)
def test_recipient(self):
assertion = BadgeAssertion.create(self.badge, self.project)
test_data = {
'idenity': self.project._id,
'type': 'osfnode',
'hashed': False
}
assert_equals(assertion.recipient, test_data)
def test_awarder(self):
assertion = BadgeAssertion.create(self.badge, self.project)
assert_equals(assertion.awarder, self.usersettings)
def test_move_file_out_of_node(self):
folder = self.root_node.append_folder('A long time ago')
file = folder.append_file('in a galaxy')
# project having a preprint should not block other moves
preprint_file = self.root_node.append_file('far')
self.node.preprint_file = preprint_file
self.node.save()
project = ProjectFactory(creator=self.user)
project_settings = project.get_addon('osfstorage')
project_root_node = project_settings.get_root()
folder_two = project_root_node.append_folder('far away')
res = self.send_hook(
'osfstorage_move_hook',
{'nid': self.root_node.node._id},
payload={
'source': folder._id,
'node': self.root_node._id,
'user': self.user._id,
'destination': {
'parent': folder_two._id,
'node': folder_two.node._id,
'name': folder_two.name,
}
},
method='post_json',
expect_errors=True,
)
assert_equal(res.status_code, 200)
def test_move_preprint_file_out_of_node(self):
folder = self.root_node.append_folder('From Here')
file = folder.append_file('No I don\'t wanna go')
self.node.preprint_file = file
self.node.save()
project = ProjectFactory(creator=self.user)
project_settings = project.get_addon('osfstorage')
project_root_node = project_settings.get_root()
folder_two = project_root_node.append_folder('To There')
res = self.send_hook(
'osfstorage_move_hook',
{'nid': self.root_node.node._id},
payload={
'source': folder._id,
'node': self.root_node._id,
'user': self.user._id,
'destination': {
'parent': folder_two._id,
'node': folder_two.node._id,
'name': folder_two.name,
}
},
method='post_json',
expect_errors=True,
)
assert_equal(res.status_code, 403)
class TestNodeSettings(OsfTestCase):
def setUp(self):
super(TestNodeSettings, self).setUp()
self.user = AuthUserFactory()
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('figshare', auth=Auth(self.user))
self.project.creator.add_addon('figshare')
self.node_settings = self.project.get_addon('figshare')
self.user_settings = self.project.creator.get_addon('figshare')
self.user_settings.oauth_access_token = 'legittoken'
self.user_settings.oauth_access_token_secret = 'legittoken'
self.user_settings.save()
self.node_settings.user_settings = self.user_settings
self.node_settings.figshare_id = '123456'
self.node_settings.figshare_type = 'project'
self.node_settings.figshare_title = 'singlefile'
self.node_settings.save()
def test_complete_true(self):
assert_true(self.node_settings.has_auth)
assert_true(self.node_settings.complete)
def test_complete_false(self):
self.node_settings.figshare_id = None
assert_true(self.node_settings.has_auth)
assert_false(self.node_settings.complete)
def test_complete_auth_false(self):
self.node_settings.user_settings = None
assert_false(self.node_settings.has_auth)
assert_false(self.node_settings.complete)
class TestNodeSettings(OsfTestCase):
def setUp(self):
super(TestNodeSettings, self).setUp()
self.user = UserFactory()
self.project = ProjectFactory(creator=self.user)
self.user.add_addon('s3')
self.project.add_addon('s3', auth=Auth(self.user))
self.user_settings = self.user.get_addon('s3')
self.node_settings = self.project.get_addon('s3')
self.user_settings.access_key = 'We-Will-Rock-You'
self.user_settings.secret_key = 'Idontknowanyqueensongs'
self.user_settings.save()
self.node_settings.bucket = 'Sheer-Heart-Attack'
self.node_settings.user_settings = self.user_settings
self.node_settings.save()
def test_complete_true(self):
assert_true(self.node_settings.has_auth)
assert_true(self.node_settings.complete)
def test_complete_false(self):
self.node_settings.bucket = None
assert_true(self.node_settings.has_auth)
assert_false(self.node_settings.complete)
def test_complete_auth_false(self):
self.node_settings.user_settings = None
assert_false(self.node_settings.has_auth)
assert_false(self.node_settings.complete)
class TestFileGuid(OsfTestCase):
def setUp(self):
super(OsfTestCase, self).setUp()
self.user = UserFactory()
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('github', auth=Auth(self.user))
self.node_addon = self.project.get_addon('github')
def test_provider(self):
assert_equal('github', GithubGuidFile().provider)
def test_correct_path(self):
guid, _ = self.node_addon.find_or_create_file_guid('perth')
assert_equal(guid.waterbutler_path, 'perth')
assert_equal(guid.waterbutler_path, guid.path)
@mock.patch('website.addons.base.requests.get')
def test_unique_identifier(self, mock_get):
mock_response = mock.Mock(ok=True, status_code=200)
mock_get.return_value = mock_response
mock_response.json.return_value = {
'data': {
'name': 'Morty',
'extra': {
'fileSha': 'Im a little tea pot'
}
}
}
guid, _ = self.node_addon.find_or_create_file_guid('perth')
guid.enrich()
assert_equal(guid.unique_identifier, 'Im a little tea pot')
def test_exception_from_response(self):
mock_response = mock.Mock()
mock_response.json.return_value = {'errors': [{'code': 'too_large'}]}
guid, _ = self.node_addon.find_or_create_file_guid('perth')
with assert_raises(TooBigToRenderError):
guid._exception_from_response(mock_response)
def test_node_addon_get_or_create(self):
guid, created = self.node_addon.find_or_create_file_guid('/4/2')
assert_true(created)
assert_equal(guid.waterbutler_path, '/4/2')
def test_node_addon_get_or_create_finds(self):
guid1, created1 = self.node_addon.find_or_create_file_guid('/foo/bar')
guid2, created2 = self.node_addon.find_or_create_file_guid('/foo/bar')
assert_true(created1)
assert_false(created2)
assert_equals(guid1, guid2)
class TestGoogleDriveUtils(OsfTestCase):
def setUp(self):
super(TestGoogleDriveUtils, self).setUp()
self.user = AuthUserFactory()
self.user.add_addon('googledrive')
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('googledrive', Auth(self.user))
self.node_settings = self.project.get_addon('googledrive')
self.user_settings = self.user.get_addon('googledrive')
oauth_settings = GoogleDriveOAuthSettingsFactory()
self.user_settings.oauth_settings = oauth_settings
self.node_settings.user_settings = self.user_settings
self.node_settings.folder_id = '09120912'
self.node_settings.folder_path = 'foo/bar'
self.user_settings.save()
self.node_settings.save()
# Log user in
self.app.authenticate(*self.user.auth)
def test_serialize_settings_helper_returns_correct_urls(self):
result = serialize_settings(self.node_settings, self.user)
urls = result['urls']
assert_equal(urls['files'], self.project.web_url_for('collect_file_trees'))
assert_equal(urls['config'], self.project.api_url_for('googledrive_config_put'))
assert_equal(urls['deauthorize'], self.project.api_url_for('googledrive_deauthorize'))
assert_equal(urls['importAuth'], self.project.api_url_for('googledrive_import_user_auth'))
# Includes endpoint for fetching folders only
# NOTE: Querystring params are in camelCase
assert_equal(urls['get_folders'], self.project.api_url_for('googledrive_folders'))
def test_serialize_settings_helper_returns_correct_auth_info(self):
self.user_settings.access_token = 'abc123'
result = serialize_settings(self.node_settings, self.user)
assert_equal(result['nodeHasAuth'], self.node_settings.has_auth)
assert_true(result['userHasAuth'])
assert_true(result['userIsOwner'])
def test_serialize_settings_for_user_no_auth(self):
no_addon_user = AuthUserFactory()
result = serialize_settings(self.node_settings, no_addon_user)
assert_false(result['userIsOwner'])
assert_false(result['userHasAuth'])
def test_googledrive_import_user_auth_returns_serialized_settings(self):
self.node_settings.user_settings = None
self.node_settings.save()
url = api_url_for('googledrive_import_user_auth', pid=self.project._primary_key)
res = self.app.put(url, auth=self.user.auth)
self.project.reload()
self.node_settings.reload()
expected_result = serialize_settings(self.node_settings, self.user)
result = res.json['result']
assert_equal(result, expected_result)
class TestOsfStorageCheckout(StorageTestCase):
def setUp(self):
super(TestOsfStorageCheckout, self).setUp()
self.user = factories.AuthUserFactory()
self.node = ProjectFactory(creator=self.user)
self.osfstorage = self.node.get_addon('osfstorage')
self.root_node = self.osfstorage.get_root()
self.file = self.root_node.append_file('3005')
def test_delete_checked_out_file(self):
self.file.checkout = self.user
self.file.save()
with assert_raises(FileNodeCheckedOutError):
self.file.delete()
def test_delete_folder_with_checked_out_file(self):
folder = self.root_node.append_folder('folder')
self.file.move_under(folder)
self.file.checkout = self.user
self.file.save()
with assert_raises(FileNodeCheckedOutError):
folder.delete()
def test_move_checked_out_file(self):
self.file.checkout = self.user
self.file.save()
folder = self.root_node.append_folder('folder')
with assert_raises(FileNodeCheckedOutError):
self.file.move_under(folder)
def test_checked_out_merge(self):
user = factories.AuthUserFactory()
node = ProjectFactory(creator=user)
osfstorage = node.get_addon('osfstorage')
root_node = osfstorage.get_root()
file = root_node.append_file('test_file')
user_merge_target = factories.AuthUserFactory()
file.checkout = user
file.save()
user_merge_target.merge_user(user)
file.reload()
assert_equal(user_merge_target, file.checkout)
def test_remove_contributor_with_checked_file(self):
user = factories.AuthUserFactory()
self.node.contributors.append(user)
self.node.add_permission(user, 'admin')
self.node.visible_contributor_ids.append(user._id)
self.node.save()
self.file.checkout = self.user
self.file.save()
self.file.node.remove_contributors([self.user], save=True)
self.file.reload()
assert_equal(self.file.checkout, None)
class TestCommentViews(OsfTestCase):
def setUp(self):
super(TestCommentViews, self).setUp()
self.project = ProjectFactory(is_public=True)
self.user = AuthUserFactory()
self.project.add_contributor(self.user)
self.project.save()
self.user.save()
def test_view_project_comments_updates_user_comments_view_timestamp(self):
url = self.project.api_url_for('update_comments_timestamp')
res = self.app.put_json(url, {
'page': 'node',
'rootId': self.project._id
}, auth=self.user.auth)
self.user.reload()
user_timestamp = self.user.comments_viewed_timestamp[self.project._id]['node']
view_timestamp = dt.datetime.utcnow()
assert_datetime_equal(user_timestamp, view_timestamp)
def test_confirm_non_contrib_viewers_dont_have_pid_in_comments_view_timestamp(self):
non_contributor = AuthUserFactory()
url = self.project.api_url_for('update_comments_timestamp')
res = self.app.put_json(url, {
'page': 'node',
'rootId': self.project._id
}, auth=self.user.auth)
non_contributor.reload()
assert_not_in(self.project._id, non_contributor.comments_viewed_timestamp)
def test_view_comments_updates_user_comments_view_timestamp_files(self):
osfstorage = self.project.get_addon('osfstorage')
root_node = osfstorage.get_root()
test_file = root_node.append_file('test_file')
test_file.create_version(self.user, {
'object': '06d80e',
'service': 'cloud',
osfstorage_settings.WATERBUTLER_RESOURCE: 'osf',
}, {
'size': 1337,
'contentType': 'img/png'
}).save()
url = self.project.api_url_for('update_comments_timestamp')
res = self.app.put_json(url, {
'page': 'files',
'rootId': test_file._id
}, auth=self.user.auth)
self.user.reload()
user_timestamp = self.user.comments_viewed_timestamp[self.project._id]['files'][test_file._id]
view_timestamp = dt.datetime.utcnow()
assert_datetime_equal(user_timestamp, view_timestamp)
class TestFileVersionView(ApiTestCase):
def setUp(self):
super(TestFileVersionView, self).setUp()
self.user = AuthUserFactory()
self.node = ProjectFactory(creator=self.user)
self.osfstorage = self.node.get_addon("osfstorage")
self.root_node = self.osfstorage.get_root()
self.file = self.root_node.append_file("test_file")
self.file.create_version(
self.user,
{"object": "06d80e", "service": "cloud", osfstorage_settings.WATERBUTLER_RESOURCE: "osf"},
{"size": 1337, "contentType": "img/png"},
).save()
def test_listing(self):
self.file.create_version(
self.user,
{"object": "0683m38e", "service": "cloud", osfstorage_settings.WATERBUTLER_RESOURCE: "osf"},
{"size": 1347, "contentType": "img/png"},
).save()
res = self.app.get("/{}files/{}/versions/".format(API_BASE, self.file._id), auth=self.user.auth)
assert_equal(res.status_code, 200)
assert_equal(len(res.json["data"]), 2)
assert_equal(res.json["data"][0]["id"], "1")
assert_equal(res.json["data"][1]["id"], "2")
def test_by_id(self):
res = self.app.get("/{}files/{}/versions/1/".format(API_BASE, self.file._id), auth=self.user.auth)
assert_equal(res.status_code, 200)
assert_equal(res.json["data"]["id"], "1")
def test_read_only(self):
assert_equal(
self.app.put(
"/{}files/{}/versions/1/".format(API_BASE, self.file._id), expect_errors=True, auth=self.user.auth
).status_code,
405,
)
assert_equal(
self.app.post(
"/{}files/{}/versions/1/".format(API_BASE, self.file._id), expect_errors=True, auth=self.user.auth
).status_code,
405,
)
assert_equal(
self.app.delete(
"/{}files/{}/versions/1/".format(API_BASE, self.file._id), expect_errors=True, auth=self.user.auth
).status_code,
405,
)
class TestFileGuid(OsfTestCase):
def setUp(self):
super(OsfTestCase, self).setUp()
self.user = UserFactory()
self.project = ProjectFactory(creator=self.user)
self.project.add_addon("github", auth=Auth(self.user))
self.node_addon = self.project.get_addon("github")
def test_provider(self):
assert_equal("github", GithubGuidFile().provider)
def test_correct_path(self):
guid, _ = self.node_addon.find_or_create_file_guid("perth")
assert_equal(guid.waterbutler_path, "perth")
assert_equal(guid.waterbutler_path, guid.path)
def test_extra_without_metadata(self):
guid, _ = self.node_addon.find_or_create_file_guid("perth")
assert_equal(guid.extra, {})
@mock.patch("website.addons.base.requests.get")
def test_unique_identifier(self, mock_get):
mock_response = mock.Mock(ok=True, status_code=200)
mock_get.return_value = mock_response
mock_response.json.return_value = {"data": {"name": "Morty", "extra": {"fileSha": "Im a little tea pot"}}}
guid, _ = self.node_addon.find_or_create_file_guid("perth")
guid.enrich()
assert_equal(guid.unique_identifier, "Im a little tea pot")
def test_exception_from_response(self):
mock_response = mock.Mock()
mock_response.json.return_value = {"errors": [{"code": "too_large"}]}
guid, _ = self.node_addon.find_or_create_file_guid("perth")
with assert_raises(TooBigToRenderError):
guid._exception_from_response(mock_response)
def test_node_addon_get_or_create(self):
guid, created = self.node_addon.find_or_create_file_guid("/4/2")
assert_true(created)
assert_equal(guid.waterbutler_path, "/4/2")
def test_node_addon_get_or_create_finds(self):
guid1, created1 = self.node_addon.find_or_create_file_guid("/foo/bar")
guid2, created2 = self.node_addon.find_or_create_file_guid("/foo/bar")
assert_true(created1)
assert_false(created2)
assert_equals(guid1, guid2)
def test_delete_node(self):
node = ProjectFactory(is_public=True, title='The Soul Album')
osf_storage = node.get_addon('osfstorage')
root = osf_storage.get_root()
root.append_file('The Dock of the Bay.mp3')
find = query_file('The Dock of the Bay.mp3')['results']
assert_equal(len(find), 1)
node.is_deleted = True
node.save()
find = query_file('The Dock of the Bay.mp3')['results']
assert_equal(len(find), 0)
def test_checked_out_merge(self):
user = factories.AuthUserFactory()
node = ProjectFactory(creator=user)
osfstorage = node.get_addon('osfstorage')
root_node = osfstorage.get_root()
file = root_node.append_file('test_file')
user_merge_target = factories.AuthUserFactory()
file.checkout = user
file.save()
user_merge_target.merge_user(user)
file.reload()
assert_equal(user_merge_target, file.checkout)
def test_log_deauthorized_when_node_settings_are_deleted(self):
project = ProjectFactory()
project.add_addon('box', auth=Auth(project.creator))
dbox_settings = project.get_addon('box')
dbox_settings.delete(save=True)
# sanity check
assert_true(dbox_settings.deleted)
logger = utils.BoxNodeLogger(node=project, auth=Auth(self.user))
logger.log(action='node_deauthorized', save=True)
last_log = project.logs[-1]
assert_equal(last_log.action, 'box_node_deauthorized')
def test_node_count_deleted_addon(self):
results = AddonSnapshot().get_events()
github_res = [res for res in results if res["provider"]["name"] == "github"][0]
assert_equal(github_res["nodes"]["deleted"], 0)
node = ProjectFactory(creator=self.user)
node.add_addon("github", Auth(self.user))
node_addon = node.get_addon("github")
node_addon.delete()
results = AddonSnapshot().get_events()
github_res = [res for res in results if res["provider"]["name"] == "github"][0]
assert_equal(github_res["nodes"]["deleted"], 1)
class StorageTestCase(OsfTestCase):
def setUp(self):
super(StorageTestCase, self).setUp()
self.project = ProjectFactory()
self.user = self.project.creator
self.node_settings = self.project.get_addon('osfstorage')
self.auth_obj = Auth(user=self.project.creator)
# Refresh records from database; necessary for comparing dates
self.project.reload()
self.user.reload()
def test_checked_out_merge(self):
user = factories.AuthUserFactory()
node = ProjectFactory(creator=user)
osfstorage = node.get_addon("osfstorage")
root_node = osfstorage.get_root()
file = root_node.append_file("test_file")
user_merge_target = factories.AuthUserFactory()
file.check_in_or_out(user, user, save=True)
file.reload()
assert_equal(file.checkout, user)
user_merge_target.merge_user(user)
file.reload()
assert_equal(user_merge_target, file.checkout)
def test_node_count_deleted_addon(self):
results = AddonSnapshot().get_events()
github_res = [res for res in results if res['provider']['name'] == 'github'][0]
assert_equal(github_res['nodes']['deleted'], 0)
node = ProjectFactory(creator=self.user)
node.add_addon('github', Auth(self.user))
node_addon = node.get_addon('github')
node_addon.delete()
results = AddonSnapshot().get_events()
github_res = [res for res in results if res['provider']['name'] == 'github'][0]
assert_equal(github_res['nodes']['deleted'], 1)
class TestS3ViewsHgrid(OsfTestCase):
def setUp(self):
super(TestS3ViewsHgrid, self).setUp()
self.user = AuthUserFactory()
self.consolidated_auth = Auth(user=self.user)
self.auth = ('test', self.user.api_keys[0]._primary_key)
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('s3', auth=self.consolidated_auth)
self.project.creator.add_addon('s3')
self.user_settings = self.user.get_addon('s3')
self.user_settings.access_key = 'We-Will-Rock-You'
self.user_settings.secret_key = 'Idontknowanyqueensongs'
self.user_settings.save()
self.node_settings = self.project.get_addon('s3')
self.node_settings.bucket = 'Sheer-Heart-Attack'
self.node_settings.user_settings = self.project.creator.get_addon('s3')
self.node_settings.save()
def test_data_contents_no_user_settings(self):
self.node_settings.user_settings = None
self.node_settings.save()
url = "/api/v1/project/{0}/s3/hgrid/".format(self.project._id)
rv = self.app.get(url, expect_errors=True, auth=self.user.auth)
assert_equals(rv.status_int, http.BAD_REQUEST)
def test_dummy_folder(self):
url = "/api/v1/project/{0}/s3/hgrid/dummy/".format(self.project._id)
rv = self.app.get(url, auth=self.user.auth)
assert_true(self.node_settings.bucket in rv.body)
def test_dummy_folder_no_user_settings(self):
self.node_settings.user_settings = None
self.node_settings.save()
url = "/api/v1/project/{0}/s3/hgrid/dummy/".format(self.project._id)
rv = self.app.get(url, auth=self.user.auth)
assert_equals(rv.body, 'null')
def test_dummy_folder_no_bucket(self):
self.node_settings.bucket = None
self.node_settings.save()
url = "/api/v1/project/{0}/s3/hgrid/dummy/".format(self.project._id)
rv = self.app.get(url, auth=self.user.auth)
assert_equals(rv.body, 'null')
class TestFileGuid(OsfTestCase):
def setUp(self):
super(OsfTestCase, self).setUp()
self.user = factories.AuthUserFactory()
self.project = ProjectFactory(creator=self.user)
self.node_addon = self.project.get_addon('osfstorage')
def test_provider(self):
assert_equal('osfstorage', model.OsfStorageGuidFile().provider)
def test_correct_path(self):
guid = model.OsfStorageGuidFile(node=self.project, path='/baz/foo/bar')
assert_equals(guid.path, '/baz/foo/bar')
assert_equal(guid.path, guid.waterbutler_path)
assert_equals(guid.waterbutler_path, '/baz/foo/bar')
@mock.patch('website.addons.base.requests.get')
def test_unique_identifier(self, mock_get):
mock_response = mock.Mock(ok=True, status_code=200)
mock_get.return_value = mock_response
mock_response.json.return_value = {
'data': {
'name': 'Morty',
'extra': {
'version': 'Terran it up'
}
}
}
guid = model.OsfStorageGuidFile(node=self.project, path='/foo/bar')
guid.enrich()
assert_equals('Terran it up', guid.unique_identifier)
def test_node_addon_get_or_create(self):
guid, created = self.node_addon.find_or_create_file_guid('/baz/foo/bar')
assert_true(created)
assert_equal(guid.path, '/baz/foo/bar')
assert_equal(guid.path, guid.waterbutler_path)
assert_equal(guid.waterbutler_path, '/baz/foo/bar')
def test_node_addon_get_or_create_finds(self):
guid1, created1 = self.node_addon.find_or_create_file_guid('/foo/bar')
guid2, created2 = self.node_addon.find_or_create_file_guid('/foo/bar')
assert_true(created1)
assert_false(created2)
assert_equals(guid1, guid2)
def test_migration_removes_targets(self):
project = ProjectFactory(creator=self.user1)
project.add_addon('box', auth=Auth(self.user1))
node_addon = project.get_addon('box')
node_addon.foreign_user_settings = self.user1_settings
node_addon.save()
assert_equal(get_targets().count(), 1)
do_migration([self.user1_settings])
self.user1_settings.reload()
assert_equal(get_targets().count(), 0)
class TestNodeSettingsModel(OsfTestCase):
def setUp(self):
super(TestNodeSettingsModel, self).setUp()
self.user = AuthUserFactory()
self.project = ProjectFactory()
self.project.add_addon('badges', self.user.auth)
self.node_settings = self.project.get_addon('badges')
def test_exists(self):
assert_true(self.node_settings)
def test_does_nothing(self):
pass
def test_node_count_disconected_addon(self):
results = AddonSnapshot().get_events()
github_res = [
res for res in results if res['provider']['name'] == 'github'
][0]
assert_equal(github_res['nodes']['disconnected'], 0)
node = ProjectFactory(creator=self.user)
node.add_addon('github', Auth(self.user))
node_addon = node.get_addon('github')
node_addon.external_account = None
node_addon.save()
results = AddonSnapshot().get_events()
github_res = [
res for res in results if res['provider']['name'] == 'github'
][0]
assert_equal(github_res['nodes']['disconnected'], 1)
def test_set_user_auth(self):
project = ProjectFactory()
project.add_addon('dataverse', auth=Auth(self.user))
node_settings = project.get_addon('dataverse')
num_old_logs = len(project.logs)
assert_false(node_settings.user_settings)
node_settings.set_user_auth(self.user_settings)
node_settings.save()
assert_equal(node_settings.user_settings, self.user_settings)
# Test log
project.reload()
assert_equal(len(project.logs), num_old_logs + 1)
last_log = project.logs[-1]
assert_equal(last_log.action, 'dataverse_node_authorized')
assert_equal(last_log.params['node'], project._primary_key)
assert_is_none(last_log.params['project'])
class TestS3Api(OsfTestCase):
def setUp(self):
super(TestS3Api, self).setUp()
self.user = UserFactory()
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('s3')
self.project.creator.add_addon('s3')
self.s3 = create_mock_s3()
self.node_settings = self.project.get_addon('s3')
self.node_settings.user_settings = self.project.creator.get_addon('s3')
# Set the node addon settings to correspond to the values of the mock repo
self.node_settings.has_bucket = True
self.node_settings.save()
class TestGoogleDriveHgridViews(OsfTestCase):
def setUp(self):
super(TestGoogleDriveHgridViews, self).setUp()
self.account = GoogleDriveAccountFactory()
self.user = AuthUserFactory(external_accounts=[self.account])
self.user_settings = self.user.get_or_add_addon('googledrive')
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('googledrive', Auth(self.user))
self.node_settings = self.project.get_addon('googledrive')
self.node_settings.user_settings = self.user_settings
self.user_settings.save()
self.node_settings.save()
# Log user in
self.app.authenticate(*self.user.auth)
@mock.patch.object(GoogleDriveClient, 'folders')
def test_googledrive_folders(self, mock_drive_client_folders):
folderId = '12345'
self.node_settings.set_auth(external_account=self.account,
user=self.user)
self.node_settings.save()
mock_drive_client_folders.return_value = sample_folder_data['items']
url = self.project.api_url_for('googledrive_folders',
folderId=folderId)
res = self.app.get(url)
assert_equal(res.status_code, 200)
assert_equal(len(res.json), len(sample_folder_data['items']))
@mock.patch(
'website.addons.googledrive.views.hgrid.GoogleDriveClient.about')
def test_googledrive_folders_returns_only_root(self, mock_about):
mock_about.return_value = {'rootFolderId': '24601'}
self.node_settings.set_auth(external_account=self.account,
user=self.user)
self.node_settings.save()
url = self.project.api_url_for('googledrive_folders')
res = self.app.get(url, auth=self.user.auth)
assert_equal(len(res.json), 1)
assert_equal(res.status_code, 200)
assert_equal(res.json[0]['id'], '24601')
def test_migration_removes_targets(self):
GoogleDriveUserSettings.remove()
user = UserFactory()
project = ProjectFactory(creator=user)
user.add_addon('googledrive', auth=Auth(user))
user_addon = user.get_addon('googledrive')
user_addon.oauth_settings = GoogleDriveOAuthSettingsFactory()
user_addon.save()
project.add_addon('googledrive', auth=Auth(user))
node_addon = project.get_addon('googledrive')
node_addon.foreign_user_settings = user_addon
node_addon.save()
assert_equal(get_targets().count(), 1)
do_migration([user_addon])
user_addon.reload()
assert_equal(get_targets().count(), 0)
def test_many_nodes_with_one_addon(self):
results = AddonSnapshot().get_events()
github_res = [
res for res in results if res['provider']['name'] == 'github'
][0]
assert_equal(github_res['nodes']['total'], 1)
node = ProjectFactory(creator=self.user)
node.add_addon('github', Auth(self.user))
node_addon = node.get_addon('github')
node_addon.user = self.user.fullname
node_addon.repo = '8 (circle)'
node_addon.user_settings = self.user_addon
node_addon.external_account = self.oauth_settings
node_addon.save()
node.save()
results = AddonSnapshot().get_events()
github_res = [
res for res in results if res['provider']['name'] == 'github'
][0]
assert_equal(github_res['nodes']['total'], 2)
class TestMigrateDates(OsfTestCase):
def setUp(self):
super(TestMigrateDates, self).setUp()
self.path = 'old-pizza'
self.project = ProjectFactory()
self.node_settings = self.project.get_addon('osfstorage')
self.node_file = NodeFile(path=self.path)
self.node_file.save()
self.date = self.node_file.date_modified
self.project.files_versions['old_pizza'] = [self.node_file._id]
self.project.save()
self.version = FileVersionFactory(
date_modified=datetime.datetime.now())
self.record = OsfStorageFileRecord.get_or_create(
self.node_file.path, self.node_settings)
self.record.versions = [self.version]
self.record.save()
def test_migrate_dates(self):
assert_not_equal(self.version.date_modified, self.date)
main(dry_run=False)
assert_equal(self.version.date_modified, self.date)
def test_migration_includes_project(self):
user = UserFactory()
project = ProjectFactory(creator=user)
api_token = 'api-token-2345'
user.add_addon('dataverse', auth=Auth(user))
user_addon = user.get_addon('dataverse')
user_addon.api_token = api_token
user_addon.save()
project.add_addon('dataverse', auth=Auth(user))
node_addon = project.get_addon('dataverse')
node_addon.user_settings = user_addon
node_addon.save()
do_migration([user_addon], dry=False)
user_addon.reload()
node_addon.reload()
account = user_addon.external_accounts[0]
assert_equal(account, node_addon.external_account)
class TestHGridViews(OsfTestCase):
def setUp(self):
super(TestHGridViews, self).setUp()
self.github = github_mock
self.user = AuthUserFactory()
self.consolidated_auth = Auth(user=self.user)
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('github', auth=self.consolidated_auth)
self.project.creator.add_addon('github')
self.node_settings = self.project.get_addon('github')
self.node_settings.user_settings = self.project.creator.get_addon('github')
# Set the node addon settings to correspond to the values of the mock repo
self.node_settings.user = self.github.repo.return_value.owner.login
self.node_settings.repo = self.github.repo.return_value.name
self.node_settings.save()
def test_to_hgrid(self):
contents = github_mock.contents(user='******', repo='hello', ref='12345abc')
res = views.hgrid.to_hgrid(
contents,
node_url=self.project.url, node_api_url=self.project.api_url,
max_size=10
)
assert_equal(len(res), 2)
assert_equal(res[0]['addon'], 'github')
assert_true(res[0]['permissions']['view']) # can always view
expected_kind = 'item' if contents['octokit'].type == 'file' else 'folder'
assert_equal(res[0]['kind'], expected_kind)
assert_equal(res[0]['accept']['maxSize'], 10)
assert_equal(res[0]['accept']['acceptedFiles'], None)
assert_equal(res[0]['urls'], api.build_github_urls(contents['octokit'],
self.project.url, self.project.api_url, branch=None, sha=None))
# Files should not have lazy-load or upload URLs
assert_not_in('lazyLoad', res[0])
assert_not_in('uploadUrl', res[0])
def test_do_migration(self):
bad_project = ProjectFactory()
auth = Auth(bad_project.creator)
bad_project.add_addon('osffiles', auth=auth)
bad_project.add_addon('osffiles', auth=auth, _force=True)
bad_project.save()
bad_project2 = ProjectFactory()
auth2 = Auth(bad_project2.creator)
bad_project2.add_addon('wiki', auth=auth2)
bad_project2.add_addon('wiki', auth=auth2, _force=True)
bad_project2.save()
# sanity check
with assert_raises(AssertionError):
bad_project.get_addon('osffiles')
with assert_raises(AssertionError):
bad_project2.get_addon('wiki')
do_migration(self.db)
# no more errors
assert isinstance(bad_project.get_addon('wiki'), AddonWikiNodeSettings)
assert isinstance(bad_project2.get_addon('osffiles'), AddonFilesNodeSettings)
class TestCallbacks(OsfTestCase):
def setUp(self):
super(TestCallbacks, self).setUp()
self.user = AuthUserFactory()
self.consolidated_auth = Auth(user=self.user)
self.auth = ('test', self.user.api_keys[0]._primary_key)
self.project = ProjectFactory(creator=self.user)
self.non_authenticator = AuthUserFactory()
self.project.add_contributor(
contributor=self.non_authenticator,
auth=Auth(self.project.creator),
)
self.project.add_addon('figshare', auth=self.consolidated_auth)
self.project.creator.add_addon('figshare')
self.node_settings = self.project.get_addon('figshare')
self.user_settings = self.project.creator.get_addon('figshare')
self.user_settings.oauth_access_token = 'legittoken'
self.user_settings.oauth_access_token_secret = 'legittoken'
self.user_settings.save()
self.node_settings.user_settings = self.user_settings
self.node_settings.figshare_id = '123456'
self.node_settings.figshare_type = 'project'
self.node_settings.figshare_title = 'singlefile'
self.node_settings.save()
def test_update_fields_project(self):
num_logs = len(self.project.logs)
# try updating fields
newfields = {
'type': 'project',
'id': '313131',
'title': 'A PROJECT'
}
self.node_settings.update_fields(newfields, self.project, Auth(self.project.creator))
#check for updated
assert_equals(self.node_settings.figshare_id, '313131')
assert_equals(self.node_settings.figshare_type, 'project')
assert_equals(self.node_settings.figshare_title, 'A PROJECT')
# check for log added
assert_equals(len(self.project.logs), num_logs+1)
def test_update_fields_fileset(self):
num_logs = len(self.project.logs)
# try updating fields
newfields = {
'type': 'fileset',
'id': '313131',
'title': 'A FILESET'
}
self.node_settings.update_fields(newfields, self.project, Auth(self.project.creator))
#check for updated
assert_equals(self.node_settings.figshare_id, '313131')
assert_equals(self.node_settings.figshare_type, 'fileset')
assert_equals(self.node_settings.figshare_title, 'A FILESET')
# check for log added
assert_equals(len(self.project.logs), num_logs+1)
def test_update_fields_some_missing(self):
num_logs = len(self.project.logs)
# try updating fields
newfields = {
'type': 'project',
'id': '313131',
'title': 'A PROJECT'
}
self.node_settings.update_fields(newfields, self.project, Auth(self.project.creator))
#check for updated
assert_equals(self.node_settings.figshare_id, '313131')
assert_equals(self.node_settings.figshare_title, 'A PROJECT')
# check for log added
assert_equals(len(self.project.logs), num_logs+1)
def test_update_fields_invalid(self):
num_logs = len(self.project.logs)
# try updating fields
newfields = {
'adad' : 131313,
'i1513': '313131',
'titladad': 'A PROJECT'
}
self.node_settings.update_fields(newfields, self.project, Auth(self.project.creator))
#check for updated
assert_equals(self.node_settings.figshare_id, '123456')
assert_equals(self.node_settings.figshare_type, 'project')
assert_equals(self.node_settings.figshare_title, 'singlefile')
# check for log added
assert_equals(len(self.project.logs), num_logs)
def test_api_url_no_user(self):
self.node_settings.user_settings = None
self.node_settings.save()
assert_equal(self.node_settings.api_url, figshare_settings.API_URL)
def test_api_url(self):
assert_equal(self.node_settings.api_url, figshare_settings.API_OAUTH_URL)
def test_before_register_linked_content(self):
assert_false(
self.node_settings.before_register(
self.project,
self.project.creator
) is None
)
def test_before_register_no_linked_content(self):
self.node_settings.figshare_id = None
assert_true(
self.node_settings.before_register(
self.project,
self.project.creator
) is None
)
def test_before_remove_contributor_authenticator(self):
message = self.node_settings.before_remove_contributor(
self.project, self.project.creator
)
assert_true(message)
def test_before_remove_contributor_not_authenticator(self):
message = self.node_settings.before_remove_contributor(
self.project, self.non_authenticator
)
assert_false(message)
def test_after_remove_contributor_authenticator(self):
self.node_settings.after_remove_contributor(
self.project, self.project.creator
)
assert_equal(
self.node_settings.user_settings,
None
)
def test_after_fork_authenticator(self):
fork = ProjectFactory()
clone, message = self.node_settings.after_fork(
self.project, fork, self.project.creator,
)
assert_equal(
self.node_settings.user_settings,
clone.user_settings,
)
def test_after_fork_not_authenticator(self):
fork = ProjectFactory()
clone, message = self.node_settings.after_fork(
self.project, fork, self.non_authenticator,
)
assert_equal(
clone.user_settings,
None,
)
def test_after_delete(self):
self.project.remove_node(Auth(user=self.project.creator))
# Ensure that changes to node settings have been saved
self.node_settings.reload()
assert_true(self.node_settings.user_settings is None)
assert_true(self.node_settings.figshare_id is None)
assert_true(self.node_settings.figshare_type is None)
assert_true(self.node_settings.figshare_title is None)
#TODO Test figshare options and figshare to_json
class TestCreateBucket(OsfTestCase):
def setUp(self):
super(TestCreateBucket, self).setUp()
self.user = AuthUserFactory()
self.consolidated_auth = Auth(user=self.user)
self.auth = ('test', self.user.api_keys[0]._primary_key)
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('s3', auth=self.consolidated_auth)
self.project.creator.add_addon('s3')
self.user_settings = self.user.get_addon('s3')
self.user_settings.access_key = 'We-Will-Rock-You'
self.user_settings.secret_key = 'Idontknowanyqueensongs'
self.user_settings.save()
self.node_settings = self.project.get_addon('s3')
self.node_settings.bucket = 'Sheer-Heart-Attack'
self.node_settings.user_settings = self.project.creator.get_addon('s3')
self.node_settings.save()
def test_bad_names(self):
assert_false(validate_bucket_name('bogus naMe'))
assert_false(validate_bucket_name(''))
assert_false(validate_bucket_name('no'))
assert_false(validate_bucket_name('.cantstartwithp'))
assert_false(validate_bucket_name('or.endwith.'))
assert_false(validate_bucket_name('..nodoubles'))
assert_false(validate_bucket_name('no_unders_in'))
def test_names(self):
assert_true(validate_bucket_name('imagoodname'))
assert_true(validate_bucket_name('still.passing'))
assert_true(validate_bucket_name('can-have-dashes'))
assert_true(validate_bucket_name('kinda.name.spaced'))
@mock.patch('website.addons.s3.views.crud.create_bucket')
@mock.patch('website.addons.s3.utils.get_bucket_drop_down')
def test_create_bucket_pass(self, mock_make, mock_dropdown):
mock_make.return_value = True
mock_dropdown.return_value = ['mybucket']
url = self.project.api_url_for('create_new_bucket')
ret = self.app.post_json(url, {'bucket_name': 'doesntevenmatter'},
auth=self.user.auth)
assert_equals(ret.status_int, http.OK)
@mock.patch('website.addons.s3.views.crud.create_bucket')
def test_create_bucket_fail(self, mock_make):
error = S3ResponseError(418, 'because Im a test')
error.message = 'This should work'
mock_make.side_effect = error
url = "/api/v1/project/{0}/s3/newbucket/".format(self.project._id)
ret = self.app.post_json(url, {'bucket_name': 'doesntevenmatter'},
auth=self.user.auth,
expect_errors=True)
assert_equals(
ret.body,
'{"message": "This should work", "title": "Problem connecting to S3"}'
)
class TestViewsConfig(OsfTestCase):
def setUp(self):
super(TestViewsConfig, self).setUp()
self.user = AuthUserFactory()
self.consolidated_auth = Auth(user=self.user)
self.auth = ('test', self.user.api_keys[0]._primary_key)
self.project = ProjectFactory(creator=self.user)
self.non_authenticator = AuthUserFactory()
self.project.add_contributor(
contributor=self.non_authenticator,
auth=Auth(self.project.creator),
)
self.project.add_addon('figshare', auth=self.consolidated_auth)
self.project.creator.add_addon('figshare')
self.node_settings = self.project.get_addon('figshare')
self.user_settings = self.project.creator.get_addon('figshare')
self.user_settings.oauth_access_token = 'legittoken'
self.user_settings.oauth_access_token_secret = 'legittoken'
self.user_settings.save()
self.node_settings.user_settings = self.user_settings
self.node_settings.figshare_id = '123456'
self.node_settings.figshare_type = 'project'
self.node_settings.figshare_title = 'FIGSHARE_TITLE'
self.node_settings.save()
self.figshare = create_mock_figshare('test')
def configure_responses(self):
httpretty.register_uri(
httpretty.GET,
join_path(self.node_settings.api_url, 'articles'),
body=dumps(self.figshare.articles.return_value)
)
httpretty.register_uri(
httpretty.GET,
join_path(self.node_settings.api_url, 'articles', '902210'),
body=dumps(self.figshare.article.return_value)
)
@httpretty.activate
def test_import_auth(self):
self.configure_responses()
"""Testing figshare_import_user_auth to ensure that auth gets imported correctly"""
settings = self.node_settings
settings.user_settings = None
settings.save()
url = '/api/v1/project/{0}/figshare/config/import-auth/'.format(self.project._id)
self.app.put(url, auth=self.user.auth)
self.node_settings.reload()
assert_is_not_none(settings.user_settings)
def test_cancelled_oauth_request_from_user_settings_page_redirects_correctly(self):
res = self.app.get(api_url_for('figshare_oauth_callback', uid=self.user._id), auth=self.user.auth)
assert_equal(res.status_code, 302)
assert_urls_equal(res.headers['location'], web_url_for('user_addons'))
def test_cancelled_oauth_request_from_node_settings_page_redirects_correctly(self):
res = self.app.get(api_url_for('figshare_oauth_callback', uid=self.user._id, nid=self.project._id), auth=self.user.auth)
assert_equal(res.status_code, 302)
assert_urls_equal(res.headers['location'], self.project.web_url_for('node_setting'))
def test_deauthorize(self):
"""Testing figshare_deauthorize to ensure user auth gets removed from
the node and that the AddonNodeSettings are cleared
"""
settings = self.node_settings
url = '/api/v1/project/{0}/figshare/config/'.format(self.project._id)
self.app.delete(url, auth=self.user.auth)
self.node_settings.reload()
assert_true(settings.user_settings is None)
is_none = (
settings.figshare_id is None and settings.figshare_title is None and settings.figshare_type is None
)
assert_true(is_none)
def test_config_no_change(self):
nlogs = len(self.project.logs)
url = self.project.api_url_for('figshare_config_put')
rv = self.app.put_json(
url,
{
'selected': {
'id': '123456',
'name': 'FIGSHARE_TITLE',
'type': 'project',
},
},
auth=self.user.auth,
)
self.project.reload()
assert_equal(rv.status_int, http.OK)
assert_equal(len(self.project.logs), nlogs)
def test_config_change(self):
nlogs = len(self.project.logs)
url = self.project.api_url_for('figshare_config_put')
rv = self.app.put_json(
url,
{
'selected': {
'id': 'project_9001',
'name': 'IchangedbecauseIcan',
'type': 'project'
},
},
auth=self.user.auth,
)
self.project.reload()
self.node_settings.reload()
assert_equal(rv.status_int, http.OK)
assert_equal(self.node_settings.figshare_id, 'project_9001')
assert_equal(self.node_settings.figshare_title, 'IchangedbecauseIcan')
assert_equal(len(self.project.logs), nlogs + 1)
assert_equal(
self.project.logs[nlogs].action,
'figshare_content_linked'
)
def test_config_change_invalid(self):
nlogs = len(self.project.logs)
url = self.project.api_url_for('figshare_config_put')
rv = self.app.put_json(
url,
{
'selected': {
'type': 'project'
},
},
auth=self.user.auth,
expect_errors=True,
)
self.project.reload()
self.node_settings.reload()
assert_equal(rv.status_int, http.BAD_REQUEST)
assert_equal(len(self.project.logs), nlogs)
def test_config_change_not_owner(self):
user2 = AuthUserFactory()
self.project.add_contributor(user2, save=True)
nlogs = len(self.project.logs)
url = self.project.api_url_for('figshare_config_put')
res = self.app.put_json(
url,
{},
auth=user2.auth,
expect_errors=True,
)
self.project.reload()
assert_equal(res.status_int, http.FORBIDDEN)
assert_equal(nlogs, len(self.project.logs))
@httpretty.activate
def test_serialize_settings_helper_returns_correct_auth_info(self):
self.configure_responses()
result = serialize_settings(self.node_settings, self.user, client=figshare_mock)
assert_equal(result['nodeHasAuth'], self.node_settings.has_auth)
assert_true(result['userHasAuth'])
assert_true(result['userIsOwner'])
@httpretty.activate
def test_serialize_settings_for_user_no_auth(self):
self.configure_responses()
no_addon_user = AuthUserFactory()
result = serialize_settings(self.node_settings, no_addon_user, client=figshare_mock)
assert_false(result['userIsOwner'])
assert_false(result['userHasAuth'])
class TestFileGuid(OsfTestCase):
def setUp(self):
super(OsfTestCase, self).setUp()
self.user = UserFactory()
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('box', auth=Auth(self.user))
self.node_addon = self.project.get_addon('box')
def test_provider(self):
assert_equal('box', BoxFile().provider)
def test_correct_path(self):
guid = BoxFile(node=self.project, path='1234567890/foo/bar')
assert_equals(guid.path, '1234567890/foo/bar')
assert_equals(guid.waterbutler_path, '/1234567890/foo/bar')
@mock.patch('website.addons.base.requests.get')
def test_unique_identifier(self, mock_get):
uid = '#!'
mock_response = mock.Mock(ok=True, status_code=200)
mock_get.return_value = mock_response
mock_response.json.return_value = {
'data': {
'extra': {
'etag': uid
},
}
}
guid = BoxFile(node=self.project, path='1234567890/foo/bar')
guid.enrich()
assert_equals(uid, guid.unique_identifier)
@mock.patch('website.addons.base.requests.get')
def test_unique_identifier_version(self, mock_get):
uid = '#!'
mock_response = mock.Mock(ok=True, status_code=200)
mock_get.return_value = mock_response
mock_response.json.return_value = {
'data': {
'extra': {},
'version': uid
}
}
guid = BoxFile(node=self.project, path='1234567890/foo/bar')
guid.enrich()
assert_equals(uid, guid.unique_identifier)
def test_node_addon_get_or_create(self):
guid, created = self.node_addon.find_or_create_file_guid(
'1234567890/foo/bar')
assert_true(created)
assert_equal(guid.path, '1234567890/foo/bar')
assert_equal(guid.waterbutler_path, '/1234567890/foo/bar')
def test_node_addon_get_or_create_finds(self):
guid1, created1 = self.node_addon.find_or_create_file_guid('/foo/bar')
guid2, created2 = self.node_addon.find_or_create_file_guid('/foo/bar')
assert_true(created1)
assert_false(created2)
assert_equals(guid1, guid2)
class TestAddonLogs(OsfTestCase):
def setUp(self):
super(TestAddonLogs, self).setUp()
self.flask_app = SetEnvironMiddleware(self.app.app, REMOTE_ADDR='127.0.0.1')
self.test_app = webtest.TestApp(self.flask_app)
self.user = AuthUserFactory()
self.auth_obj = Auth(user=self.user)
self.node = ProjectFactory(creator=self.user)
self.session = Session(data={'auth_user_id': self.user._id})
self.session.save()
self.cookie = itsdangerous.Signer(settings.SECRET_KEY).sign(self.session._id)
self.configure_addon()
def configure_addon(self):
self.user.add_addon('github')
self.user_addon = self.user.get_addon('github')
self.oauth_settings = AddonGitHubOauthSettings(github_user_id='john')
self.oauth_settings.save()
self.user_addon.oauth_settings = self.oauth_settings
self.user_addon.oauth_access_token = 'secret'
self.user_addon.save()
self.node.add_addon('github', self.auth_obj)
self.node_addon = self.node.get_addon('github')
self.node_addon.user = '******'
self.node_addon.repo = 'youre-my-best-friend'
self.node_addon.user_settings = self.user_addon
self.node_addon.save()
def build_payload(self, metadata, **kwargs):
options = dict(
auth={'id': self.user._id},
action='create',
provider=self.node_addon.config.short_name,
metadata=metadata,
time=time.time() + 1000,
)
options.update(kwargs)
options = {
key: value
for key, value in options.iteritems()
if value is not None
}
message, signature = signing.default_signer.sign_payload(options)
return {
'payload': message,
'signature': signature,
}
def test_add_log(self):
path = 'pizza'
url = self.node.api_url_for('create_waterbutler_log')
payload = self.build_payload(metadata={'path': path})
nlogs = len(self.node.logs)
self.test_app.put_json(url, payload, headers={'Content-Type': 'application/json'})
self.node.reload()
assert_equal(len(self.node.logs), nlogs + 1)
def test_add_log_missing_args(self):
path = 'pizza'
url = self.node.api_url_for('create_waterbutler_log')
payload = self.build_payload(metadata={'path': path}, auth=None)
nlogs = len(self.node.logs)
res = self.test_app.put_json(
url,
payload,
headers={'Content-Type': 'application/json'},
expect_errors=True,
)
assert_equal(res.status_code, 400)
self.node.reload()
assert_equal(len(self.node.logs), nlogs)
def test_add_log_no_user(self):
path = 'pizza'
url = self.node.api_url_for('create_waterbutler_log')
payload = self.build_payload(metadata={'path': path}, auth={'id': None})
nlogs = len(self.node.logs)
res = self.test_app.put_json(
url,
payload,
headers={'Content-Type': 'application/json'},
expect_errors=True,
)
assert_equal(res.status_code, 400)
self.node.reload()
assert_equal(len(self.node.logs), nlogs)
def test_add_log_no_addon(self):
path = 'pizza'
node = ProjectFactory(creator=self.user)
url = node.api_url_for('create_waterbutler_log')
payload = self.build_payload(metadata={'path': path})
nlogs = len(node.logs)
res = self.test_app.put_json(
url,
payload,
headers={'Content-Type': 'application/json'},
expect_errors=True,
)
assert_equal(res.status_code, 400)
self.node.reload()
assert_equal(len(node.logs), nlogs)
def test_add_log_bad_action(self):
path = 'pizza'
url = self.node.api_url_for('create_waterbutler_log')
payload = self.build_payload(metadata={'path': path}, action='dance')
nlogs = len(self.node.logs)
res = self.test_app.put_json(
url,
payload,
headers={'Content-Type': 'application/json'},
expect_errors=True,
)
assert_equal(res.status_code, 400)
self.node.reload()
assert_equal(len(self.node.logs), nlogs)
class TestNodeFilesList(ApiTestCase):
def setUp(self):
super(TestNodeFilesList, self).setUp()
self.user = AuthUserFactory()
self.project = ProjectFactory(creator=self.user)
self.private_url = '/{}nodes/{}/files/'.format(API_BASE,
self.project._id)
self.user_two = AuthUserFactory()
self.public_project = ProjectFactory(creator=self.user, is_public=True)
self.public_url = '/{}nodes/{}/files/'.format(API_BASE,
self.public_project._id)
httpretty.enable()
def tearDown(self):
super(TestNodeFilesList, self).tearDown()
httpretty.disable()
httpretty.reset()
def _prepare_mock_wb_response(self, node=None, **kwargs):
prepare_mock_wb_response(node=node or self.project, **kwargs)
def test_cannot_access_retracted_files_list(self):
registration = RegistrationFactory(creator=self.user,
project=self.public_project)
url = '/{}nodes/{}/files/'.format(API_BASE, registration._id)
retraction = RetractedRegistrationFactory(registration=registration,
user=registration.creator)
res = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 404)
def test_returns_public_files_logged_out(self):
res = self.app.get(self.public_url, expect_errors=True)
assert_equal(res.status_code, 200)
assert_equal(res.json['data'][0]['attributes']['provider'],
'osfstorage')
assert_equal(res.content_type, 'application/vnd.api+json')
def test_returns_public_files_logged_in(self):
res = self.app.get(self.public_url, auth=self.user.auth)
assert_equal(res.status_code, 200)
assert_equal(res.content_type, 'application/vnd.api+json')
assert_equal(res.json['data'][0]['attributes']['provider'],
'osfstorage')
def test_returns_file_data(self):
fobj = self.project.get_addon('osfstorage').get_root().append_file(
'NewFile')
fobj.save()
res = self.app.get('{}osfstorage/{}'.format(self.private_url,
fobj._id),
auth=self.user.auth)
assert_equal(res.status_code, 200)
assert_true(isinstance(res.json['data'], dict))
assert_equal(res.content_type, 'application/vnd.api+json')
assert_equal(res.json['data']['attributes']['kind'], 'file')
assert_equal(res.json['data']['attributes']['name'], 'NewFile')
def test_returns_folder_data(self):
fobj = self.project.get_addon('osfstorage').get_root().append_folder(
'NewFolder')
fobj.save()
res = self.app.get('{}osfstorage/{}/'.format(self.private_url,
fobj._id),
auth=self.user.auth)
assert_equal(res.status_code, 200)
assert_equal(len(res.json['data']), 0)
assert_equal(res.content_type, 'application/vnd.api+json')
def test_returns_private_files_logged_out(self):
res = self.app.get(self.private_url, expect_errors=True)
assert_equal(res.status_code, 401)
assert_in('detail', res.json['errors'][0])
def test_returns_private_files_logged_in_contributor(self):
res = self.app.get(self.private_url, auth=self.user.auth)
assert_equal(res.status_code, 200)
assert_equal(res.content_type, 'application/vnd.api+json')
assert_equal(len(res.json['data']), 1)
assert_equal(res.json['data'][0]['attributes']['provider'],
'osfstorage')
def test_returns_private_files_logged_in_non_contributor(self):
res = self.app.get(self.private_url,
auth=self.user_two.auth,
expect_errors=True)
assert_equal(res.status_code, 403)
assert_in('detail', res.json['errors'][0])
def test_returns_addon_folders(self):
user_auth = Auth(self.user)
res = self.app.get(self.private_url, auth=self.user.auth)
assert_equal(len(res.json['data']), 1)
assert_equal(res.json['data'][0]['attributes']['provider'],
'osfstorage')
self.project.add_addon('github', auth=user_auth)
addon = self.project.get_addon('github')
addon.repo = 'something'
addon.user = '******'
oauth_settings = GitHubAccountFactory()
oauth_settings.save()
self.user.add_addon('github')
self.user.external_accounts.append(oauth_settings)
self.user.save()
addon.user_settings = self.user.get_addon('github')
addon.save()
self.project.save()
res = self.app.get(self.private_url, auth=self.user.auth)
data = res.json['data']
providers = [item['attributes']['provider'] for item in data]
assert_equal(len(data), 2)
assert_in('github', providers)
assert_in('osfstorage', providers)
def test_returns_node_files_list(self):
self._prepare_mock_wb_response(provider='github',
files=[{
'name': 'NewFile'
}])
url = '/{}nodes/{}/files/github/'.format(API_BASE, self.project._id)
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.json['data'][0]['attributes']['name'], 'NewFile')
assert_equal(res.json['data'][0]['attributes']['provider'], 'github')
def test_returns_node_file(self):
self._prepare_mock_wb_response(provider='github',
files=[{
'name': 'NewFile'
}],
folder=False,
path='/file')
url = '/{}nodes/{}/files/github/file'.format(API_BASE,
self.project._id)
res = self.app.get(
url,
auth=self.user.auth,
headers={
'COOKIE': 'foo=bar;' # Webtests doesnt support cookies?
})
assert_equal(res.status_code, 200)
assert_equal(res.json['data']['attributes']['name'], 'NewFile')
assert_equal(res.json['data']['attributes']['provider'], 'github')
def test_notfound_node_file_returns_folder(self):
self._prepare_mock_wb_response(provider='github',
files=[{
'name': 'NewFile'
}],
path='/file')
url = '/{}nodes/{}/files/github/file'.format(API_BASE,
self.project._id)
res = self.app.get(
url,
auth=self.user.auth,
expect_errors=True,
headers={
'COOKIE': 'foo=bar;' # Webtests doesnt support cookies?
})
assert_equal(res.status_code, 404)
def test_notfound_node_folder_returns_file(self):
self._prepare_mock_wb_response(provider='github',
files=[{
'name': 'NewFile'
}],
folder=False,
path='/')
url = '/{}nodes/{}/files/github/'.format(API_BASE, self.project._id)
res = self.app.get(
url,
auth=self.user.auth,
expect_errors=True,
headers={
'COOKIE': 'foo=bar;' # Webtests doesnt support cookies?
})
assert_equal(res.status_code, 404)
def test_waterbutler_server_error_returns_503(self):
self._prepare_mock_wb_response(status_code=500)
url = '/{}nodes/{}/files/github/'.format(API_BASE, self.project._id)
res = self.app.get(
url,
auth=self.user.auth,
expect_errors=True,
headers={
'COOKIE': 'foo=bar;' # Webtests doesnt support cookies?
})
assert_equal(res.status_code, 503)
def test_waterbutler_invalid_data_returns_503(self):
wb_url = waterbutler_api_url_for(self.project._id,
provider='github',
path='/',
meta=True)
httpretty.register_uri(httpretty.GET,
wb_url,
body=json.dumps({}),
status=400)
url = '/{}nodes/{}/files/github/'.format(API_BASE, self.project._id)
res = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 503)
def test_handles_unauthenticated_waterbutler_request(self):
self._prepare_mock_wb_response(status_code=401)
url = '/{}nodes/{}/files/github/'.format(API_BASE, self.project._id)
res = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 403)
assert_in('detail', res.json['errors'][0])
def test_handles_notfound_waterbutler_request(self):
invalid_provider = 'gilkjadsflhub'
self._prepare_mock_wb_response(status_code=404,
provider=invalid_provider)
url = '/{}nodes/{}/files/{}/'.format(API_BASE, self.project._id,
invalid_provider)
res = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 404)
assert_in('detail', res.json['errors'][0])
def test_handles_bad_waterbutler_request(self):
wb_url = waterbutler_api_url_for(self.project._id,
provider='github',
path='/',
meta=True)
httpretty.register_uri(httpretty.GET,
wb_url,
body=json.dumps({}),
status=418)
url = '/{}nodes/{}/files/github/'.format(API_BASE, self.project._id)
res = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 503)
assert_in('detail', res.json['errors'][0])
def test_files_list_contains_relationships_object(self):
res = self.app.get(self.public_url, auth=self.user.auth)
assert_equal(res.status_code, 200)
assert 'relationships' in res.json['data'][0]
class TestFileVersionView(ApiTestCase):
def setUp(self):
super(TestFileVersionView, self).setUp()
self.user = AuthUserFactory()
self.node = ProjectFactory(creator=self.user)
self.osfstorage = self.node.get_addon('osfstorage')
self.root_node = self.osfstorage.get_root()
self.file = self.root_node.append_file('test_file')
self.file.create_version(
self.user, {
'object': '06d80e',
'service': 'cloud',
osfstorage_settings.WATERBUTLER_RESOURCE: 'osf',
}, {
'size': 1337,
'contentType': 'img/png'
}).save()
def test_listing(self):
self.file.create_version(
self.user, {
'object': '0683m38e',
'service': 'cloud',
osfstorage_settings.WATERBUTLER_RESOURCE: 'osf',
}, {
'size': 1347,
'contentType': 'img/png'
}).save()
res = self.app.get(
'/{}files/{}/versions/'.format(API_BASE, self.file._id),
auth=self.user.auth,
)
assert_equal(res.status_code, 200)
assert_equal(len(res.json['data']), 2)
assert_equal(res.json['data'][0]['id'], '1')
assert_equal(res.json['data'][1]['id'], '2')
def test_by_id(self):
res = self.app.get(
'/{}files/{}/versions/1/'.format(API_BASE, self.file._id),
auth=self.user.auth,
)
assert_equal(res.status_code, 200)
assert_equal(res.json['data']['id'], '1')
def test_read_only(self):
assert_equal(
self.app.put(
'/{}files/{}/versions/1/'.format(API_BASE, self.file._id),
expect_errors=True,
auth=self.user.auth,
).status_code, 405)
assert_equal(
self.app.post(
'/{}files/{}/versions/1/'.format(API_BASE, self.file._id),
expect_errors=True,
auth=self.user.auth,
).status_code, 405)
assert_equal(
self.app.delete(
'/{}files/{}/versions/1/'.format(API_BASE, self.file._id),
expect_errors=True,
auth=self.user.auth,
).status_code, 405)
class TestAddonFileViews(OsfTestCase):
@classmethod
def setUpClass(cls):
super(TestAddonFileViews, cls).setUpClass()
PROVIDER_MAP['github'] = [TestFolder, TestFile, TestFileNode]
TestFileNode.provider = 'github'
def setUp(self):
super(TestAddonFileViews, self).setUp()
self.user = AuthUserFactory()
self.project = ProjectFactory(creator=self.user)
self.user.add_addon('github')
self.project.add_addon('github', auth=Auth(self.user))
self.user_addon = self.user.get_addon('github')
self.node_addon = self.project.get_addon('github')
self.oauth = AddonGitHubOauthSettings(github_user_id='denbarell',
oauth_access_token='Truthy')
self.oauth.save()
self.user_addon.oauth_settings = self.oauth
self.user_addon.save()
self.node_addon.user_settings = self.user_addon
self.node_addon.repo = 'Truth'
self.node_addon.user = '******'
self.node_addon.save()
@classmethod
def tearDownClass(cls):
super(TestAddonFileViews, cls).tearDownClass()
PROVIDER_MAP['github'] = [
models.GithubFolder, models.GithubFile, models.GithubFileNode
]
del PROVIDER_MAP['test_addons']
def get_test_file(self):
ret = TestFile(name='Test',
node=self.project,
path='/test/Test',
materialized_path='/test/Test')
ret.save()
return ret
def get_mako_return(self):
ret = serialize_node(self.project, Auth(self.user), primary=True)
ret.update({
'error': '',
'provider': '',
'file_path': '',
'sharejs_uuid': '',
'private': '',
'urls': {
'files': '',
'render': '',
'sharejs': '',
'mfr': '',
'gravatar': '',
'external': '',
},
'size': '',
'extra': '',
'file_name': '',
'materialized_path': '',
})
ret.update(rubeus.collect_addon_assets(self.project))
return ret
def test_redirects_to_guid(self):
file_node = self.get_test_file()
guid = file_node.get_guid(create=True)
resp = self.app.get(self.project.web_url_for(
'addon_view_or_download_file',
path=file_node.path.strip('/'),
provider='github'),
auth=self.user.auth)
assert_equals(resp.status_code, 302)
assert_equals(resp.location,
'http://*****:*****@mock.patch('website.addons.base.views.addon_view_file')
def test_action_view_calls_view_file(self, mock_view_file):
self.user.reload()
self.project.reload()
file_node = self.get_test_file()
guid = file_node.get_guid(create=True)
mock_view_file.return_value = self.get_mako_return()
self.app.get('/{}/?action=view'.format(guid._id), auth=self.user.auth)
args, kwargs = mock_view_file.call_args
assert_equals(kwargs, {})
assert_equals(args[0].user, self.user)
assert_equals(args[1], self.project)
assert_equals(args[2], file_node)
assert_true(isinstance(args[3], file_node.touch(None).__class__))
@mock.patch('website.addons.base.views.addon_view_file')
def test_no_action_calls_view_file(self, mock_view_file):
self.user.reload()
self.project.reload()
file_node = self.get_test_file()
guid = file_node.get_guid(create=True)
mock_view_file.return_value = self.get_mako_return()
self.app.get('/{}/'.format(guid._id), auth=self.user.auth)
args, kwargs = mock_view_file.call_args
assert_equals(kwargs, {})
assert_equals(args[0].user, self.user)
assert_equals(args[1], self.project)
assert_equals(args[2], file_node)
assert_true(isinstance(args[3], file_node.touch(None).__class__))
def test_download_create_guid(self):
file_node = self.get_test_file()
assert_is(file_node.get_guid(), None)
self.app.get(self.project.web_url_for(
'addon_view_or_download_file',
path=file_node.path.strip('/'),
provider='github',
),
auth=self.user.auth)
assert_true(file_node.get_guid())
def test_unauthorized_addons_raise(self):
path = 'cloudfiles'
self.node_addon.user_settings = None
self.node_addon.save()
resp = self.app.get(self.project.web_url_for(
'addon_view_or_download_file',
path=path,
provider='github',
action='download'),
auth=self.user.auth,
expect_errors=True)
assert_equals(resp.status_code, 401)
def test_nonstorage_addons_raise(self):
resp = self.app.get(self.project.web_url_for(
'addon_view_or_download_file',
path='sillywiki',
provider='wiki',
action='download'),
auth=self.user.auth,
expect_errors=True)
assert_equals(resp.status_code, 400)
def test_head_returns_url(self):
file_node = self.get_test_file()
guid = file_node.get_guid(create=True)
resp = self.app.head('/{}/'.format(guid._id), auth=self.user.auth)
location = furl.furl(resp.location)
assert_urls_equal(location.url,
file_node.generate_waterbutler_url(direct=None))
def test_nonexistent_addons_raise(self):
path = 'cloudfiles'
self.project.delete_addon('github', Auth(self.user))
self.project.save()
resp = self.app.get(self.project.web_url_for(
'addon_view_or_download_file',
path=path,
provider='github',
action='download'),
auth=self.user.auth,
expect_errors=True)
assert_equals(resp.status_code, 400)
def test_unauth_addons_raise(self):
path = 'cloudfiles'
self.node_addon.user_settings = None
self.node_addon.save()
resp = self.app.get(self.project.web_url_for(
'addon_view_or_download_file',
path=path,
provider='github',
action='download'),
auth=self.user.auth,
expect_errors=True)
assert_equals(resp.status_code, 401)
class TestAddonLogs(OsfTestCase):
def setUp(self):
super(TestAddonLogs, self).setUp()
self.flask_app = SetEnvironMiddleware(self.app.app,
REMOTE_ADDR='127.0.0.1')
self.test_app = webtest.TestApp(self.flask_app)
self.user = AuthUserFactory()
self.auth_obj = Auth(user=self.user)
self.node = ProjectFactory(creator=self.user)
self.session = Session(data={'auth_user_id': self.user._id})
self.session.save()
self.cookie = itsdangerous.Signer(settings.SECRET_KEY).sign(
self.session._id)
self.configure_addon()
def configure_addon(self):
self.user.add_addon('github')
self.user_addon = self.user.get_addon('github')
self.oauth_settings = AddonGitHubOauthSettings(github_user_id='john')
self.oauth_settings.save()
self.user_addon.oauth_settings = self.oauth_settings
self.user_addon.oauth_access_token = 'secret'
self.user_addon.save()
self.node.add_addon('github', self.auth_obj)
self.node_addon = self.node.get_addon('github')
self.node_addon.user = '******'
self.node_addon.repo = 'youre-my-best-friend'
self.node_addon.user_settings = self.user_addon
self.node_addon.save()
def build_payload(self, metadata, **kwargs):
options = dict(
auth={'id': self.user._id},
action='create',
provider=self.node_addon.config.short_name,
metadata=metadata,
time=time.time() + 1000,
)
options.update(kwargs)
options = {
key: value
for key, value in options.iteritems() if value is not None
}
message, signature = signing.default_signer.sign_payload(options)
return {
'payload': message,
'signature': signature,
}
@mock.patch('website.notifications.events.files.FileAdded.perform')
def test_add_log(self, mock_perform):
path = 'pizza'
url = self.node.api_url_for('create_waterbutler_log')
payload = self.build_payload(metadata={'path': path})
nlogs = len(self.node.logs)
self.test_app.put_json(url,
payload,
headers={'Content-Type': 'application/json'})
self.node.reload()
assert_equal(len(self.node.logs), nlogs + 1)
# # Mocking form_message and perform so that the payload need not be exact.
# assert_true(mock_form_message.called, "form_message not called")
assert_true(mock_perform.called, "perform not called")
def test_add_log_missing_args(self):
path = 'pizza'
url = self.node.api_url_for('create_waterbutler_log')
payload = self.build_payload(metadata={'path': path}, auth=None)
nlogs = len(self.node.logs)
res = self.test_app.put_json(
url,
payload,
headers={'Content-Type': 'application/json'},
expect_errors=True,
)
assert_equal(res.status_code, 400)
self.node.reload()
assert_equal(len(self.node.logs), nlogs)
def test_add_log_no_user(self):
path = 'pizza'
url = self.node.api_url_for('create_waterbutler_log')
payload = self.build_payload(metadata={'path': path},
auth={'id': None})
nlogs = len(self.node.logs)
res = self.test_app.put_json(
url,
payload,
headers={'Content-Type': 'application/json'},
expect_errors=True,
)
assert_equal(res.status_code, 400)
self.node.reload()
assert_equal(len(self.node.logs), nlogs)
def test_add_log_no_addon(self):
path = 'pizza'
node = ProjectFactory(creator=self.user)
url = node.api_url_for('create_waterbutler_log')
payload = self.build_payload(metadata={'path': path})
nlogs = len(node.logs)
res = self.test_app.put_json(
url,
payload,
headers={'Content-Type': 'application/json'},
expect_errors=True,
)
assert_equal(res.status_code, 400)
self.node.reload()
assert_equal(len(node.logs), nlogs)
def test_add_log_bad_action(self):
path = 'pizza'
url = self.node.api_url_for('create_waterbutler_log')
payload = self.build_payload(metadata={'path': path}, action='dance')
nlogs = len(self.node.logs)
res = self.test_app.put_json(
url,
payload,
headers={'Content-Type': 'application/json'},
expect_errors=True,
)
assert_equal(res.status_code, 400)
self.node.reload()
assert_equal(len(self.node.logs), nlogs)
def test_action_file_rename(self):
url = self.node.api_url_for('create_waterbutler_log')
payload = self.build_payload(
action='rename',
metadata={
'path': 'foo',
},
source={
'materialized': 'foo',
'provider': 'github',
'node': {
'_id': self.node._id
},
'name': 'new.txt',
'kind': 'file',
},
destination={
'path': 'foo',
'materialized': 'foo',
'provider': 'github',
'node': {
'_id': self.node._id
},
'name': 'old.txt',
'kind': 'file',
},
)
self.test_app.put_json(url,
payload,
headers={'Content-Type': 'application/json'})
self.node.reload()
assert_equal(
self.node.logs[-1].action,
'github_addon_file_renamed',
)
class TestFilesViews(OsfTestCase):
def setUp(self):
super(TestFilesViews, self).setUp()
self.user = AuthUserFactory()
self.auth = ('test', self.user.api_keys[0]._primary_key)
self.consolidated_auth = Auth(user=self.user)
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('osffiles', auth=self.consolidated_auth)
self.node_settings = self.project.get_addon('osffiles')
self.fid = 'firstfile'
self._upload_file(self.fid, 'firstcontent')
def _upload_file(self, name, content, **kwargs):
url = self.project.api_url + 'osffiles/'
res = self.app.post(url,
upload_files=[
('file', name, content),
],
auth=self.auth,
**kwargs)
self.project.reload()
return res
def test_download_file(self):
url = self.project.uploads[0].download_url(self.project)
res = self.app.get(url, auth=self.user.auth).maybe_follow()
assert_equal(res.body, 'firstcontent')
def test_download_file_by_version_with_bad_version_value(self):
url = self.project.web_url_for('download_file_by_version',
fid=self.fid,
vid='bad')
res = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_in('Invalid version', res.body)
def test_download_file_by_version_with_nonexistent_file(self):
url = self.project.web_url_for('download_file_by_version',
fid='notfound',
vid=0)
res = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 404)
def test_download_file_by_version_with_bad_version_number(self):
url = self.project.web_url_for('download_file_by_version',
fid=self.fid,
vid=9999)
res = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 404)
def test_download_file_by_version_with_negative_version_number(self):
url = self.project.web_url_for('download_file_by_version',
fid=self.fid,
vid=-1)
res = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
def test_upload_file(self):
node_addon = self.project.get_addon('osffiles')
res = self._upload_file('newfile',
'a' * (node_addon.config.max_file_size))
self.project.reload()
assert_equal(self.project.logs[-1].action, 'file_added')
assert_equal(res.status_code, 201)
assert_true(isinstance(res.json, dict), 'return value is a dict')
assert_equal(res.json['name'], 'newfile')
assert_in('newfile', self.project.files_current)
def test_upload_file_unicode_name(self):
node_addon = self.project.get_addon('osffiles')
res = self._upload_file('_néwfile',
'a' * (node_addon.config.max_file_size))
self.project.reload()
assert_equal(self.project.logs[-1].action, 'file_added')
assert_equal(res.status_code, 201)
assert_true(isinstance(res.json, dict), 'return value is a dict')
assert_equal(res.json['name'], '_newfile')
assert_in('_newfile', self.project.files_current)
def test_upload_file_too_large(self):
node_addon = self.project.get_addon('osffiles')
res = self._upload_file(
'newfile',
'a' * (node_addon.config.max_file_size + 1),
expect_errors=True,
)
self.project.reload()
assert_equal(res.status_code, 400)
assert_not_in('newfile', self.project.files_current)
def test_file_info(self):
# Upload a new version of firstfile
self._upload_file(self.fid, 'secondcontent')
url = self.project.api_url_for('file_info',
fid=self.project.uploads[0].filename)
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.status_code, 200)
file_obj = self.project.get_file_object(self.fid, version=1)
data = res.json
assert_equal(data['file_name'], self.fid)
assert_equal(data['registered'], self.project.is_registration)
assert_equal(len(data['versions']), 2)
assert_equal(data['urls']['files'],
self.project.web_url_for('collect_file_trees'))
assert_equal(data['urls']['latest']['download'],
file_obj.download_url(self.project))
assert_equal(data['urls']['api'], file_obj.api_url(self.project))
version = res.json['versions'][0]
assert_equal(version['file_name'], self.fid)
assert_equal(version['version_number'], 2)
assert_equal(version['modified_date'],
file_obj.date_uploaded.strftime('%Y/%m/%d %I:%M %p'))
assert_in('downloads', version)
assert_equal(version['committer_name'], file_obj.uploader.fullname)
assert_equal(version['committer_url'], file_obj.uploader.url)
def test_file_info_with_anonymous_link(self):
link = PrivateLinkFactory(anonymous=True)
link.nodes.append(self.project)
link.save()
self._upload_file('firstfile', 'secondcontent')
url = self.project.api_url_for('file_info',
fid=self.project.uploads[0].filename)
res = self.app.get(url, {'view_only': link.key})
assert_not_in(self.user.fullname, res.body)
assert_not_in(self.user._id, res.body)
def test_delete_file(self):
url = self.project.api_url_for('delete_file', fid=self.fid)
res = self.app.delete(url, auth=self.auth).maybe_follow()
assert_equal(res.status_code, 200)
self.project.reload()
assert_not_in('firstfile', self.project.files_current)
def test_delete_file_returns_404_when_file_is_already_deleted(self):
self.project.remove_file(Auth(self.project.creator), self.fid)
url = self.project.api_url_for('delete_file', fid=self.fid)
res = self.app.delete_json(url,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 404)
def test_file_urls(self):
url = self.project.api_url + 'osffiles/hgrid/'
res = self.app.get(url, auth=self.auth).maybe_follow()
assert_equal(len(res.json), 1)
for url in ['view', 'download', 'delete']:
assert_in(self.project._id, res.json[0]['urls'][url])
def test_file_urls_fork(self):
fork = self.project.fork_node(auth=Auth(user=self.user))
url = fork.api_url + 'osffiles/hgrid/'
res = self.app.get(url, auth=self.auth).maybe_follow()
assert_equal(len(res.json), 1)
for url in ['view', 'download', 'delete']:
assert_in(fork._id, res.json[0]['urls'][url])
def test_file_urls_registration(self):
registration = self.project.register_node(None, Auth(user=self.user),
'', '')
url = registration.api_url + 'osffiles/hgrid/'
res = self.app.get(url, auth=self.auth).maybe_follow()
assert_equal(len(res.json), 1)
for url in ['view', 'download', 'delete']:
assert_in(registration._id, res.json[0]['urls'][url])
def test_view_creates_guid(self):
guid_fid = 'unique'
guid_content = 'snowflake'
self._upload_file(guid_fid, guid_content)
node_file = NodeFile.load(self.project.files_current[guid_fid])
guid_count = OsfGuidFile.find().count()
# View file for the first time
url = node_file.url(self.project)
res = self.app.get(
url,
auth=self.user.auth,
).follow(auth=self.user.auth, )
guid = OsfGuidFile.find_one(
Q('node', 'eq', self.project) & Q('name', 'eq', guid_fid))
# GUID count has been incremented by one
assert_equal(OsfGuidFile.find().count(), guid_count + 1)
# Client has been redirected to GUID
assert_equal(
res.request.path.strip('/'),
guid._id,
)
# View file for the second time
self.app.get(
url,
auth=self.user.auth,
).follow(auth=self.user.auth, )
# GUID count has not been incremented
assert_equal(OsfGuidFile.find().count(), guid_count + 1)
def test_guid_url_returns_404(self):
f = NodeFile()
f.save()
url = '/{}/'.format(f._id)
res = self.app.get(url, expect_errors=True)
assert_equal(res.status_code, 404)
def test_sees_delete_button_if_can_write(self):
url = self.project.uploads[0].url(self.project)
res = self.app.get(
url,
auth=self.user.auth,
).maybe_follow(auth=self.user.auth, )
assert_in('Download', res)
assert_in('Delete', res)
def test_does_not_see_delete_button_if_cannot_write(self):
self.project.is_public = True
self.project.save()
user2 = AuthUserFactory()
url = self.project.uploads[0].url(self.project)
res = self.app.get(
url,
auth=user2.auth,
).maybe_follow(auth=user2.auth, )
assert_in('Download', res)
assert_not_in('Delete', res)
class TestUtils(OsfTestCase):
def setUp(self):
super(TestUtils, self).setUp()
self.user = AuthUserFactory()
self.consolidated_auth = Auth(user=self.user)
self.auth = ('test', self.user.api_keys[0]._primary_key)
self.project = ProjectFactory(creator=self.user)
self.non_authenticator = AuthUserFactory()
self.project.add_contributor(
contributor=self.non_authenticator,
auth=Auth(self.project.creator),
)
self.project.add_addon('figshare', auth=self.consolidated_auth)
self.project.creator.add_addon('figshare')
self.node_settings = self.project.get_addon('figshare')
self.user_settings = self.project.creator.get_addon('figshare')
self.user_settings.oauth_access_token = 'legittoken'
self.user_settings.oauth_access_token_secret = 'legittoken'
self.user_settings.save()
self.node_settings.user_settings = self.user_settings
self.node_settings.figshare_id = '436'
self.node_settings.figshare_type = 'project'
self.node_settings.save()
@mock.patch('website.addons.figshare.api.Figshare.project')
def test_project_to_hgrid(self, *args, **kwargs):
project = figshare_mock.project.return_value
hgrid = utils.project_to_hgrid(self.project, project, self.user, True)
assert_equals(len(hgrid), len(project['articles']))
folders_in_project = len(
[a for a in project.get('articles') or [] if a['defined_type'] == 'fileset'])
folders_in_hgrid = len([h for h in hgrid if type(h) is list])
assert_equals(folders_in_project, folders_in_hgrid)
files_in_project = 0
files_in_hgrid = 0
for a in project.get('articles') or []:
if a['defined_type'] == 'fileset':
files_in_project = files_in_project + len(a['files'])
else:
files_in_project = files_in_project + 1
for a in hgrid:
if type(a) is list:
assert_equals(a[0]['kind'], 'file')
files_in_hgrid = files_in_hgrid + len(a)
else:
assert_equals(a['kind'], 'file')
files_in_hgrid = files_in_hgrid + 1
assert_equals(files_in_hgrid, files_in_project)
@mock.patch('website.addons.figshare.api.Figshare.project')
def test_project_to_hgrid_no_auth(self, project):
project.return_value = 'notNone'
self.node_settings.user_settings = None
ref = views.hgrid.figshare_hgrid_data(self.node_settings, self.auth)
assert_equal(ref, None)
@mock.patch('website.addons.figshare.api.Figshare.project')
def test_project_to_hgrid_no_id(self, project):
project.return_value = 'not none'
self.node_settings.figshare_id = None
ref = views.hgrid.figshare_hgrid_data(self.node_settings, self.auth)
assert_equal(ref, None)
@mock.patch('website.addons.figshare.api.Figshare.project')
def test_hgrid_deleted_project(self, project):
project.return_value = None
ref = views.hgrid.figshare_hgrid_data(self.node_settings, self.auth)
assert_equal(ref, None)
class TestAddonAuth(OsfTestCase):
def setUp(self):
super(TestAddonAuth, self).setUp()
self.user = AuthUserFactory()
self.auth_obj = Auth(user=self.user)
self.node = ProjectFactory(creator=self.user)
self.session = Session(data={'auth_user_id': self.user._id})
self.session.save()
self.cookie = itsdangerous.Signer(settings.SECRET_KEY).sign(self.session._id)
self.configure_addon()
self.JWE_KEY = jwe.kdf(settings.WATERBUTLER_JWE_SECRET.encode('utf-8'), settings.WATERBUTLER_JWE_SALT.encode('utf-8'))
def configure_addon(self):
self.user.add_addon('github')
self.user_addon = self.user.get_addon('github')
self.oauth_settings = AddonGitHubOauthSettings(github_user_id='john')
self.oauth_settings.save()
self.user_addon.oauth_settings = self.oauth_settings
self.user_addon.oauth_access_token = 'secret'
self.user_addon.save()
self.node.add_addon('github', self.auth_obj)
self.node_addon = self.node.get_addon('github')
self.node_addon.user = '******'
self.node_addon.repo = 'youre-my-best-friend'
self.node_addon.user_settings = self.user_addon
self.node_addon.save()
def build_url(self, **kwargs):
options = {'payload': jwe.encrypt(jwt.encode({'data': dict(dict(
action='download',
nid=self.node._id,
provider=self.node_addon.config.short_name,
), **kwargs),
'exp': datetime.datetime.utcnow() + datetime.timedelta(seconds=settings.WATERBUTLER_JWT_EXPIRATION),
}, settings.WATERBUTLER_JWT_SECRET, algorithm=settings.WATERBUTLER_JWT_ALGORITHM), self.JWE_KEY)}
return api_url_for('get_auth', **options)
def test_auth_download(self):
url = self.build_url()
res = self.app.get(url, auth=self.user.auth)
data = jwt.decode(jwe.decrypt(res.json['payload'].encode('utf-8'), self.JWE_KEY), settings.WATERBUTLER_JWT_SECRET, algorithm=settings.WATERBUTLER_JWT_ALGORITHM)['data']
assert_equal(data['auth'], views.make_auth(self.user))
assert_equal(data['credentials'], self.node_addon.serialize_waterbutler_credentials())
assert_equal(data['settings'], self.node_addon.serialize_waterbutler_settings())
expected_url = furl.furl(self.node.api_url_for('create_waterbutler_log', _absolute=True))
observed_url = furl.furl(data['callback_url'])
observed_url.port = expected_url.port
assert_equal(expected_url, observed_url)
def test_auth_missing_args(self):
url = self.build_url(cookie=None)
res = self.app.get(url, expect_errors=True)
assert_equal(res.status_code, 401)
def test_auth_bad_cookie(self):
url = self.build_url(cookie=self.cookie)
res = self.app.get(url, expect_errors=True)
assert_equal(res.status_code, 200)
data = jwt.decode(jwe.decrypt(res.json['payload'].encode('utf-8'), self.JWE_KEY), settings.WATERBUTLER_JWT_SECRET, algorithm=settings.WATERBUTLER_JWT_ALGORITHM)['data']
assert_equal(data['auth'], views.make_auth(self.user))
assert_equal(data['credentials'], self.node_addon.serialize_waterbutler_credentials())
assert_equal(data['settings'], self.node_addon.serialize_waterbutler_settings())
expected_url = furl.furl(self.node.api_url_for('create_waterbutler_log', _absolute=True))
observed_url = furl.furl(data['callback_url'])
observed_url.port = expected_url.port
assert_equal(expected_url, observed_url)
def test_auth_cookie(self):
url = self.build_url(cookie=self.cookie[::-1])
res = self.app.get(url, expect_errors=True)
assert_equal(res.status_code, 401)
def test_auth_missing_addon(self):
url = self.build_url(provider='queenhub')
res = self.app.get(url, expect_errors=True, auth=self.user.auth)
assert_equal(res.status_code, 400)
@mock.patch('website.addons.base.views.cas.get_client')
def test_auth_bad_bearer_token(self, mock_cas_client):
mock_cas_client.return_value = mock.Mock(profile=mock.Mock(return_value=cas.CasResponse(authenticated=False)))
url = self.build_url()
res = self.app.get(url, headers={'Authorization': 'Bearer invalid_access_token'}, expect_errors=True)
assert_equal(res.status_code, 403)
class TestAddonFileViews(OsfTestCase):
def setUp(self):
super(TestAddonFileViews, self).setUp()
self.user = AuthUserFactory()
self.project = ProjectFactory(creator=self.user)
self.user.add_addon('github')
self.project.add_addon('github', auth=Auth(self.user))
self.user_addon = self.user.get_addon('github')
self.node_addon = self.project.get_addon('github')
self.oauth = AddonGitHubOauthSettings(
github_user_id='denbarell',
oauth_access_token='Truthy'
)
self.oauth.save()
self.user_addon.oauth_settings = self.oauth
self.user_addon.save()
self.node_addon.user_settings = self.user_addon
self.node_addon.save()
# self.node_addon.user_settings = 'Truthy'
# setattr(self.node_addon, 'has_auth', True)
def get_mako_return(self):
ret = serialize_node(self.project, Auth(self.user), primary=True)
ret.update({
'extra': '',
'provider': '',
'rendered': '',
'file_path': '',
'files_url': '',
'file_name': '',
'render_url': '',
})
ret.update(rubeus.collect_addon_assets(self.project))
return ret
def test_redirects_to_guid(self):
path = 'bigdata'
guid, _ = self.node_addon.find_or_create_file_guid('/' + path)
resp = self.app.get(
self.project.web_url_for(
'addon_view_or_download_file',
path=path,
provider='github'
),
auth=self.user.auth
)
assert_equals(resp.status_code, 302)
assert_equals(resp.headers['Location'], 'http://*****:*****@mock.patch('website.addons.base.request')
def test_public_download_url_includes_view_only(self, mock_request):
view_only = 'justworkplease'
mock_request.args = {
'view_only': view_only
}
path = 'cloudfiles'
guid, _ = self.node_addon.find_or_create_file_guid('/' + path)
assert_in('view_only={}'.format(view_only), guid.public_download_url)
@mock.patch('website.addons.base.views.addon_view_file')
def test_action_view_calls_view_file(self, mock_view_file):
self.user.reload()
self.project.reload()
path = 'cloudfiles'
mock_view_file.return_value = self.get_mako_return()
guid, _ = self.node_addon.find_or_create_file_guid('/' + path)
self.app.get(guid.guid_url + '?action=view', auth=self.user.auth)
args, kwargs = mock_view_file.call_args
assert_equals(kwargs, {})
assert_equals(args[-1], {'action': 'view'})
assert_equals(args[1], self.project)
assert_equals(args[0].user, self.user)
assert_equals(args[2], self.node_addon)
@mock.patch('website.addons.base.views.addon_view_file')
def test_no_action_calls_view_file(self, mock_view_file):
self.user.reload()
self.project.reload()
path = 'cloudfiles'
mock_view_file.return_value = self.get_mako_return()
guid, _ = self.node_addon.find_or_create_file_guid('/' + path)
self.app.get(guid.guid_url, auth=self.user.auth)
args, kwargs = mock_view_file.call_args
assert_equals(kwargs, {})
assert_equals(args[-1], {})
assert_equals(args[1], self.project)
assert_equals(args[0].user, self.user)
assert_equals(args[2], self.node_addon)
def test_download_create_guid(self):
path = 'cloudfiles'
self.app.get(
self.project.web_url_for(
'addon_view_or_download_file',
path=path,
provider='github',
action='download'
),
auth=self.user.auth
)
guid, created = self.node_addon.find_or_create_file_guid('/' + path)
assert_true(guid)
assert_false(created)
assert_equals(guid.waterbutler_path, '/' + path)
def test_unauthorized_addons_raise(self):
path = 'cloudfiles'
self.node_addon.user_settings = None
self.node_addon.save()
resp = self.app.get(
self.project.web_url_for(
'addon_view_or_download_file',
path=path,
provider='github',
action='download'
),
auth=self.user.auth,
expect_errors=True
)
assert_equals(resp.status_code, 403)
def test_head_returns_url(self):
path = 'the little engine that couldnt'
guid, _ = self.node_addon.find_or_create_file_guid('/' + path)
download_url = furl.furl(guid.download_url)
download_url.args['accept_url'] = 'false'
resp = self.app.head(guid.guid_url, auth=self.user.auth)
assert_urls_equal(resp.headers['Location'], download_url.url)
def test_nonexistent_addons_raise(self):
path = 'cloudfiles'
self.project.delete_addon('github', Auth(self.user))
self.project.save()
resp = self.app.get(
self.project.api_url_for(
'addon_render_file',
path=path,
provider='github',
action='download'
),
auth=self.user.auth,
expect_errors=True
)
assert_equals(resp.status_code, 400)
def test_unauth_addons_raise(self):
path = 'cloudfiles'
self.node_addon.user_settings = None
self.node_addon.save()
resp = self.app.get(
self.project.api_url_for(
'addon_render_file',
path=path,
provider='github',
action='download'
),
auth=self.user.auth,
expect_errors=True
)
assert_equals(resp.status_code, 401)
def test_unconfigured_addons_raise(self):
path = 'cloudfiles'
self.node_addon.repo = None
self.node_addon.save()
resp = self.app.get(
self.project.api_url_for(
'addon_render_file',
path=path,
provider='github',
action='download'
),
auth=self.user.auth,
expect_errors=True
)
assert_equals(resp.status_code, 400)
class TestS3ViewsConfig(OsfTestCase):
def setUp(self):
super(TestS3ViewsConfig, self).setUp()
self.user = AuthUserFactory()
self.consolidated_auth = Auth(user=self.user)
self.auth = ('test', self.user.api_keys[0]._primary_key)
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('s3', auth=self.consolidated_auth)
self.project.creator.add_addon('s3')
self.user_settings = self.user.get_addon('s3')
self.user_settings.access_key = 'We-Will-Rock-You'
self.user_settings.secret_key = 'Idontknowanyqueensongs'
self.user_settings.save()
self.node_settings = self.project.get_addon('s3')
self.node_settings.bucket = 'Sheer-Heart-Attack'
self.node_settings.user_settings = self.project.creator.get_addon('s3')
self.node_settings.save()
self.node_url = '/api/v1/project/{0}/'.format(self.project._id)
@mock.patch('website.addons.s3.views.config.does_bucket_exist')
@mock.patch('website.addons.s3.views.config.adjust_cors')
def test_s3_settings_no_bucket(self, mock_cors, mock_does_bucket_exist):
mock_does_bucket_exist.return_value = False
mock_cors.return_value = True
url = self.project.api_url + 's3/settings/'
rv = self.app.post_json(url, {},
expect_errors=True,
auth=self.user.auth)
assert_true('trouble' in rv.body)
@mock.patch('website.addons.s3.views.config.does_bucket_exist')
@mock.patch('website.addons.s3.views.config.adjust_cors')
@mock.patch('website.addons.s3.utils.get_bucket_drop_down')
def test_s3_set_bucket(self, mock_cors, mock_exist, mock_dropdown):
mock_cors.return_value = True
mock_exist.return_value = True
mock_dropdown.return_value = ['mybucket']
url = self.project.api_url_for('s3_node_settings')
self.app.post_json(
url,
{'s3_bucket': 'hammertofall'},
auth=self.user.auth,
)
self.project.reload()
self.node_settings.reload()
assert_equal(self.node_settings.bucket, 'hammertofall')
assert_equal(self.project.logs[-1].action, 's3_bucket_linked')
def test_s3_set_bucket_no_settings(self):
user = AuthUserFactory()
self.project.add_contributor(user, save=True)
url = self.project.api_url + 's3/settings/'
res = self.app.post_json(url, {'s3_bucket': 'hammertofall'},
auth=user.auth,
expect_errors=True)
assert_equal(res.status_code, http.BAD_REQUEST)
def test_s3_set_bucket_no_auth(self):
user = AuthUserFactory()
user.add_addon('s3')
self.project.add_contributor(user, save=True)
url = self.project.api_url + 's3/settings/'
res = self.app.post_json(url, {'s3_bucket': 'hammertofall'},
auth=user.auth,
expect_errors=True)
assert_equal(res.status_code, http.BAD_REQUEST)
def test_s3_set_bucket_already_authed(self):
user = AuthUserFactory()
user.add_addon('s3')
user_settings = user.get_addon('s3')
user_settings.access_key = 'foo'
user_settings.secret_key = 'bar'
user_settings.save()
self.project.add_contributor(user, save=True)
url = self.project.api_url + 's3/settings/'
res = self.app.post_json(url, {'s3_bucket': 'hammertofall'},
auth=user.auth,
expect_errors=True)
assert_equal(res.status_code, http.BAD_REQUEST)
@mock.patch('website.addons.s3.api.S3Wrapper.from_addon')
def test_s3_set_bucket_registered(self, mock_from_addon):
mock_from_addon.return_value = create_mock_wrapper()
registration = self.project.register_node(None, self.consolidated_auth,
'', '')
url = registration.api_url + 's3/settings/'
res = self.app.post_json(
url,
{'s3_bucket': 'hammertofall'},
auth=self.user.auth,
expect_errors=True,
)
assert_equal(res.status_code, http.BAD_REQUEST)
@mock.patch('website.addons.s3.views.config.has_access')
@mock.patch('website.addons.s3.views.config.create_osf_user')
def test_user_settings(self, mock_user, mock_access):
mock_access.return_value = True
mock_user.return_value = ('osf-user-12345', {
'access_key_id': 'scout',
'secret_access_key': 'ssshhhhhhhhh'
})
url = '/api/v1/settings/s3/'
self.app.post_json(url, {
'access_key': 'scout',
'secret_key': 'Atticus'
},
auth=self.user.auth)
self.user_settings.reload()
assert_equals(self.user_settings.access_key, 'scout')
@mock.patch('website.addons.s3.model.AddonS3UserSettings.remove_iam_user')
def test_s3_remove_user_settings(self, mock_access):
mock_access.return_value = True
self.user_settings.access_key = 'to-kill-a-mocking-bucket'
self.user_settings.secret_key = 'itsasecret'
self.user_settings.save()
url = api_url_for('s3_remove_user_settings')
self.app.delete(url, auth=self.user.auth)
self.user_settings.reload()
assert_equals(self.user_settings.access_key, None)
assert_equals(self.user_settings.secret_key, None)
assert_equals(mock_access.call_count, 1)
@mock.patch('website.addons.s3.model.AddonS3UserSettings.remove_iam_user')
def test_s3_remove_user_settings_none(self, mock_access):
self.user_settings.access_key = None
self.user_settings.secret_key = None
self.user_settings.save()
url = api_url_for('s3_remove_user_settings')
self.app.delete(url, auth=self.user.auth)
self.user_settings.reload()
assert_equals(mock_access.call_count, 0)
@mock.patch('website.addons.s3.views.config.has_access')
def test_user_settings_no_auth(self, mock_access):
mock_access.return_value = False
url = '/api/v1/settings/s3/'
rv = self.app.post_json(url, {},
auth=self.user.auth,
expect_errors=True)
assert_equals(rv.status_int, http.BAD_REQUEST)
@mock.patch('website.addons.s3.utils.get_bucket_drop_down')
@mock.patch('website.addons.s3.views.config.has_access')
@mock.patch('website.addons.s3.views.config.create_osf_user')
def test_node_settings_no_user_settings(self, mock_user, mock_access,
mock_dropdown):
self.node_settings.user_settings = None
self.node_settings.save()
url = self.node_url + 's3/authorize/'
mock_access.return_value = True
mock_user.return_value = ('osf-user-12345', {
'access_key_id': 'scout',
'secret_access_key': 'ssshhhhhhhhh'
})
mock_dropdown.return_value = ['mybucket']
self.app.post_json(url, {
'access_key': 'scout',
'secret_key': 'ssshhhhhhhhh'
},
auth=self.user.auth)
self.user_settings.reload()
assert_equals(self.user_settings.access_key, 'scout')
@mock.patch('website.addons.s3.utils.get_bucket_drop_down')
def test_node_settings_no_user_settings_ui(self, mock_dropdown):
mock_dropdown.return_value = ['mybucket']
self.node_settings.user_settings.access_key = None
self.node_settings.user_settings = None
self.node_settings.save()
url = self.project.url + 'settings/'
rv = self.app.get(url, auth=self.user.auth)
assert_true('<label for="s3Addon">Access Key</label>' in rv.body)
@mock.patch('website.addons.s3.utils.get_bucket_list')
def test_s3_bucket_list(self, mock_bucket_list):
fake_buckets = [
MockS3Bucket(name=fake.domain_word()) for i in range(10)
]
mock_bucket_list.return_value = fake_buckets
url = self.node_settings.owner.api_url_for('s3_bucket_list')
ret = self.app.get(url, auth=self.user.auth)
assert_equals(ret.json,
{'buckets': [bucket.name for bucket in fake_buckets]})
def test_s3_remove_node_settings_owner(self):
url = self.node_settings.owner.api_url_for('s3_remove_node_settings')
ret = self.app.delete(url, auth=self.user.auth)
assert_equal(ret.json['has_bucket'], False)
assert_equal(ret.json['node_has_auth'], False)
def test_s3_remove_node_settings_unauthorized(self):
url = self.node_settings.owner.api_url_for('s3_remove_node_settings')
ret = self.app.delete(url, auth=None, expect_errors=True)
assert_equal(ret.status_code, 401)
def test_s3_get_node_settings_owner(self):
url = self.node_settings.owner.api_url_for('s3_get_node_settings')
res = self.app.get(url, auth=self.user.auth)
expected_bucket = self.node_settings.bucket
expected_node_has_auth = True
expected_user_is_owner = True
result = res.json['result']
assert_equal(result['bucket'], expected_bucket)
assert_equal(result['node_has_auth'], expected_node_has_auth)
assert_equal(result['user_is_owner'], expected_user_is_owner)
def test_s3_get_node_settings_not_owner(self):
url = self.node_settings.owner.api_url_for('s3_get_node_settings')
non_owner = AuthUserFactory()
self.project.add_contributor(non_owner,
save=True,
permissions=['write'])
res = self.app.get(url, auth=non_owner.auth)
expected_bucket = self.node_settings.bucket
expected_node_has_auth = True
expected_user_is_owner = False
result = res.json['result']
assert_equal(result['bucket'], expected_bucket)
assert_equal(result['node_has_auth'], expected_node_has_auth)
assert_equal(result['user_is_owner'], expected_user_is_owner)
def test_s3_get_node_settings_unauthorized(self):
url = self.node_settings.owner.api_url_for('s3_get_node_settings')
unauthorized = AuthUserFactory()
ret = self.app.get(url, auth=unauthorized.auth, expect_errors=True)
assert_equal(ret.status_code, 403)
@mock.patch('website.addons.s3.views.config.add_s3_auth')
def test_s3_authorize_node_valid(self, mock_add):
mock_add.return_value = True
url = self.project.api_url_for('s3_authorize_node')
cred = {
'access_key': fake.password(),
'secret_key': fake.password(),
}
res = self.app.post_json(url, cred, auth=self.user.auth)
assert_equal(res.json['node_has_auth'], True)
def test_s3_authorize_node_invalid(self):
url = self.project.api_url_for('s3_authorize_node')
cred = {
'access_key': fake.password(),
}
res = self.app.post_json(url,
cred,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 400)
@mock.patch('website.addons.s3.views.config.add_s3_auth')
def test_s3_authorize_node_malformed(self, mock_add):
mock_add.return_value = False
url = self.project.api_url_for('s3_authorize_node')
cred = {
'access_key': fake.password(),
'secret_key': fake.password(),
}
res = self.app.post_json(url,
cred,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.json['message'], 'Incorrect credentials')
assert_equal(res.status_code, 400)
@mock.patch('website.addons.s3.views.config.add_s3_auth')
def test_s3_authorize_node_unauthorized(self, mock_add):
mock_add.return_value = True
url = self.project.api_url_for('s3_authorize_node')
cred = {
'access_key': fake.password(),
'secret_key': fake.password(),
}
unauthorized = AuthUserFactory()
res = self.app.post_json(url,
cred,
auth=unauthorized.auth,
expect_errors=True)
assert_equal(res.status_code, 403)
@mock.patch('website.addons.s3.views.config.add_s3_auth')
def test_s3_authorize_user_valid(self, mock_add):
mock_add.return_value = True
url = self.project.api_url_for('s3_authorize_user')
cred = {
'access_key': fake.password(),
'secret_key': fake.password(),
}
res = self.app.post_json(url, cred, auth=self.user.auth)
assert_equal(res.json, {})
def test_s3_authorize_user_invalid(self):
url = self.project.api_url_for('s3_authorize_user')
cred = {
'access_key': fake.password(),
}
res = self.app.post_json(url,
cred,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 400)
@mock.patch('website.addons.s3.views.config.add_s3_auth')
def test_s3_authorize_user_malformed(self, mock_add):
mock_add.return_value = False
url = self.project.api_url_for('s3_authorize_user')
cred = {
'access_key': fake.password(),
'secret_key': fake.password(),
}
res = self.app.post_json(url,
cred,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.json['message'], 'Incorrect credentials')
assert_equal(res.status_code, 400)
def test_s3_node_import_auth_authorized(self):
url = self.project.api_url_for('s3_node_import_auth')
self.node_settings.deauthorize(auth=None, save=True)
res = self.app.post(url, auth=self.user.auth)
assert_equal(res.json['node_has_auth'], True)
assert_equal(res.json['user_is_owner'], True)
def test_s3_node_import_auth_unauthorized(self):
url = self.project.api_url_for('s3_node_import_auth')
self.node_settings.deauthorize(auth=None, save=True)
unauthorized = AuthUserFactory()
res = self.app.post(url, auth=unauthorized.auth, expect_errors=True)
assert_equal(res.status_code, 403)
class TestCreateBucket(S3AddonTestCase):
def setUp(self):
super(TestCreateBucket, self).setUp()
self.user = AuthUserFactory()
self.consolidated_auth = Auth(user=self.user)
self.auth = self.user.auth
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('s3', auth=self.consolidated_auth)
self.project.creator.add_addon('s3')
self.user_settings = self.user.get_addon('s3')
self.user_settings.access_key = 'We-Will-Rock-You'
self.user_settings.secret_key = 'Idontknowanyqueensongs'
self.user_settings.save()
self.node_settings = self.project.get_addon('s3')
self.node_settings.bucket = 'Sheer-Heart-Attack'
self.node_settings.user_settings = self.project.creator.get_addon('s3')
self.node_settings.save()
def test_bad_names(self):
assert_false(validate_bucket_name(''))
assert_false(validate_bucket_name('no'))
assert_false(validate_bucket_name('a' * 64))
assert_false(validate_bucket_name(' leadingspace'))
assert_false(validate_bucket_name('trailingspace '))
assert_false(validate_bucket_name('bogus naMe'))
assert_false(validate_bucket_name('.cantstartwithp'))
assert_false(validate_bucket_name('or.endwith.'))
assert_false(validate_bucket_name('..nodoubles'))
assert_false(validate_bucket_name('no_unders_in'))
assert_false(validate_bucket_name('-leadinghyphen'))
assert_false(validate_bucket_name('trailinghyphen-'))
assert_false(validate_bucket_name('Mixedcase'))
assert_false(validate_bucket_name('empty..label'))
assert_false(validate_bucket_name('label-.trailinghyphen'))
assert_false(validate_bucket_name('label.-leadinghyphen'))
assert_false(validate_bucket_name('8.8.8.8'))
assert_false(validate_bucket_name('600.9000.0.28'))
assert_false(validate_bucket_name('no_underscore'))
assert_false(validate_bucket_name('_nounderscoreinfront'))
assert_false(validate_bucket_name('no-underscore-in-back_'))
assert_false(
validate_bucket_name('no-underscore-in_the_middle_either'))
def test_names(self):
assert_true(validate_bucket_name('imagoodname'))
assert_true(validate_bucket_name('still.passing'))
assert_true(validate_bucket_name('can-have-dashes'))
assert_true(validate_bucket_name('kinda.name.spaced'))
assert_true(validate_bucket_name('a-o.valid'))
assert_true(validate_bucket_name('11.12.m'))
assert_true(validate_bucket_name('a--------a'))
assert_true(validate_bucket_name('a' * 63))
def test_bad_locations(self):
assert_false(validate_bucket_location('Venus'))
assert_false(validate_bucket_location('AlphaCentari'))
assert_false(validate_bucket_location('CostaRica'))
def test_locations(self):
assert_true(validate_bucket_location(''))
assert_true(validate_bucket_location('us-east-2'))
assert_true(validate_bucket_location('eu-central-1'))
assert_true(validate_bucket_location('us-west-1'))
assert_true(validate_bucket_location('us-west-2'))
assert_true(validate_bucket_location('ap-northeast-1'))
assert_true(validate_bucket_location('ap-northeast-2'))
assert_true(validate_bucket_location('ap-southeast-1'))
assert_true(validate_bucket_location('ap-southeast-2'))
assert_true(validate_bucket_location('ap-south-1'))
assert_true(validate_bucket_location('sa-east-1'))
assert_true(validate_bucket_location('eu-west-1'))
@mock.patch('website.addons.s3.views.utils.create_bucket')
@mock.patch('website.addons.s3.views.utils.get_bucket_names')
def test_create_bucket_pass(self, mock_names, mock_make):
mock_make.return_value = True
mock_names.return_value = ['butintheend', 'it', 'doesntevenmatter']
url = self.project.api_url_for('create_bucket')
ret = self.app.post_json(url, {
'bucket_name': 'doesntevenmatter',
'bucket_location': '',
},
auth=self.user.auth)
assert_equal(ret.status_int, http.OK)
assert_equal(ret.json, {})
@mock.patch('website.addons.s3.views.utils.create_bucket')
def test_create_bucket_fail(self, mock_make):
error = S3ResponseError(418, 'because Im a test')
error.message = 'This should work'
mock_make.side_effect = error
url = "/api/v1/project/{0}/s3/newbucket/".format(self.project._id)
ret = self.app.post_json(url, {'bucket_name': 'doesntevenmatter'},
auth=self.user.auth,
expect_errors=True)
assert_equals(
ret.body,
'{"message": "This should work", "title": "Problem connecting to S3"}'
)
@mock.patch('website.addons.s3.views.utils.create_bucket')
def test_bad_location_fails(self, mock_make):
url = "/api/v1/project/{0}/s3/newbucket/".format(self.project._id)
ret = self.app.post_json(
url, {
'bucket_name': 'doesntevenmatter',
'bucket_location': 'not a real bucket location',
},
auth=self.user.auth,
expect_errors=True)
assert_equals(
ret.body,
'{"message": "That bucket location is not valid.", "title": "Invalid bucket location"}'
)
class TestFileGuid(OsfTestCase):
def setUp(self):
super(OsfTestCase, self).setUp()
self.user = AuthUserFactory()
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('figshare', auth=Auth(self.user))
self.node_addon = self.project.get_addon('figshare')
self.node_addon.figshare_id = 8
self.node_addon.figshare_type = 'project'
self.node_addon.save()
def test_provider(self):
assert_equal('figshare', model.FigShareGuidFile().provider)
def test_path_doesnt_crash_without_addon(self):
guid = model.FigShareGuidFile(node=self.project, path='/baz/foo/bar')
self.project.delete_addon('figshare', Auth(self.user))
assert_is(self.project.get_addon('figshare'), None)
assert_true(guid.path)
assert_true(guid.waterbutler_path)
def test_path_doesnt_crash_nonconfig_addon(self):
guid = model.FigShareGuidFile(node=self.project, path='/baz/foo/bar')
self.node_addon.figshare_type = None
self.node_addon.figshare_id = None
self.node_addon.save()
self.node_addon.reload()
assert_true(guid.path)
assert_true(guid.waterbutler_path)
def test_correct_path_article(self):
guid = model.FigShareGuidFile(file_id=2,
article_id=4,
node=self.project)
guid._metadata_cache = {'name': 'shigfare.io'}
tpath = guid.mfr_temp_path
cpath = guid.mfr_cache_path
assert_not_equal(tpath, cpath)
def test_mfr_test_path(self):
self.node_addon.figshare_type = 'fileset'
self.node_addon.save()
self.node_addon.reload()
guid = model.FigShareGuidFile(file_id=2,
article_id=4,
node=self.project)
assert_equal(guid.waterbutler_path, '/2')
def test_correct_path_project(self):
guid = model.FigShareGuidFile(file_id=2,
article_id=4,
node=self.project)
assert_equal(guid.waterbutler_path, '/4/2')
def test_unique_identifier(self):
guid = model.FigShareGuidFile(file_id=2, article_id=4)
assert_equal(guid.unique_identifier, '42')
def test_exception_from_response(self):
mock_response = mock.Mock()
mock_response.json.return_value = {
'data': {
'name': 'Morty',
'extra': {
'status': 'drafts'
}
}
}
guid = model.FigShareGuidFile(file_id=2, article_id=4)
with assert_raises(exceptions.FigshareIsDraftError):
guid._exception_from_response(mock_response)
assert_equal(guid.name, 'Morty')
@mock.patch('website.addons.base.requests.get')
def test_enrich_raises(self, mock_get):
mock_response = mock.Mock(ok=True, status_code=200)
mock_get.return_value = mock_response
mock_response.json.return_value = {
'data': {
'name': 'Morty',
'extra': {
'status': 'drafts'
}
}
}
guid = model.FigShareGuidFile(file_id=2,
article_id=4,
node=self.project)
with assert_raises(exceptions.FigshareIsDraftError):
guid.enrich()
assert_equal(guid.name, 'Morty')
@mock.patch('website.addons.base.requests.get')
def test_enrich_works(self, mock_get):
mock_response = mock.Mock(ok=True, status_code=200)
mock_get.return_value = mock_response
mock_response.json.return_value = {
'data': {
'name': 'Morty',
'extra': {
'status': 'Rick'
}
}
}
guid = model.FigShareGuidFile(file_id=2,
article_id=4,
node=self.project)
guid.enrich()
assert_equal(guid.name, 'Morty')
def test_node_addon_get_or_create(self):
guid, _ = self.node_addon.find_or_create_file_guid('/4/2')
assert_equal(guid.waterbutler_path, '/4/2')
assert_equal(guid.file_id, '2')
assert_equal(guid.article_id, '4')
def test_node_addon_get_or_create_finds(self):
guid, created = self.node_addon.find_or_create_file_guid('/4/2')
assert_true(created)
other, other_created = self.node_addon.find_or_create_file_guid('/4/2')
assert_false(other_created)
assert_equal(guid, other)
class TestLegacyViews(OsfTestCase):
def setUp(self):
super(TestLegacyViews, self).setUp()
self.path = 'mercury.png'
self.user = AuthUserFactory()
self.project = ProjectFactory(creator=self.user)
self.node_addon = self.project.get_addon('osfstorage')
file_record, _ = OsfStorageFileRecord.get_or_create(path=self.path,
node_settings=self.node_addon)
self.node_addon.save()
file_record.save()
def test_view_file_redirect(self):
url = '/{0}/osffiles/{1}/'.format(self.project._id, self.path)
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.status_code, 301)
expected_url = self.project.web_url_for(
'addon_view_or_download_file',
action='view',
path=self.path,
provider='osfstorage',
)
assert_urls_equal(res.location, expected_url)
def test_download_file_redirect(self):
url = '/{0}/osffiles/{1}/download/'.format(self.project._id, self.path)
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.status_code, 301)
expected_url = self.project.web_url_for(
'addon_view_or_download_file',
path=self.path,
action='download',
provider='osfstorage',
)
assert_urls_equal(res.location, expected_url)
def test_download_file_version_redirect(self):
url = '/{0}/osffiles/{1}/version/3/download/'.format(
self.project._id,
self.path,
)
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.status_code, 301)
expected_url = self.project.web_url_for(
'addon_view_or_download_file',
version=3,
path=self.path,
action='download',
provider='osfstorage',
)
assert_urls_equal(res.location, expected_url)
def test_api_download_file_redirect(self):
url = '/api/v1/project/{0}/osffiles/{1}/'.format(self.project._id, self.path)
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.status_code, 301)
expected_url = self.project.web_url_for(
'addon_view_or_download_file',
path=self.path,
action='download',
provider='osfstorage',
)
assert_urls_equal(res.location, expected_url)
def test_api_download_file_version_redirect(self):
url = '/api/v1/project/{0}/osffiles/{1}/version/3/'.format(
self.project._id,
self.path,
)
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.status_code, 301)
expected_url = self.project.web_url_for(
'addon_view_or_download_file',
version=3,
path=self.path,
action='download',
provider='osfstorage',
)
assert_urls_equal(res.location, expected_url)
def test_no_provider_name(self):
url = '/{0}/files/{1}'.format(
self.project._id,
self.path,
)
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.status_code, 301)
expected_url = self.project.web_url_for(
'addon_view_or_download_file',
action='view',
path=self.path,
provider='osfstorage',
)
assert_urls_equal(res.location, expected_url)
def test_action_as_param(self):
url = '/{}/osfstorage/files/{}/?action=download'.format(
self.project._id,
self.path,
)
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.status_code, 301)
expected_url = self.project.web_url_for(
'addon_view_or_download_file',
path=self.path,
action='download',
provider='osfstorage',
)
assert_urls_equal(res.location, expected_url)
def test_other_addon_redirect(self):
url = '/project/{0}/mycooladdon/files/{1}/'.format(
self.project._id,
self.path,
)
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.status_code, 301)
expected_url = self.project.web_url_for(
'addon_view_or_download_file',
action='view',
path=self.path,
provider='mycooladdon',
)
assert_urls_equal(res.location, expected_url)
def test_other_addon_redirect_download(self):
url = '/project/{0}/mycooladdon/files/{1}/download/'.format(
self.project._id,
self.path,
)
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.status_code, 301)
expected_url = self.project.web_url_for(
'addon_view_or_download_file',
path=self.path,
action='download',
provider='mycooladdon',
)
assert_urls_equal(res.location, expected_url)
class TestSearchFiles(SearchTestCase):
def setUp(self):
super(TestSearchFiles, self).setUp()
self.node = ProjectFactory(is_public=True, title='Otis')
self.osf_storage = self.node.get_addon('osfstorage')
self.root = self.osf_storage.get_root()
def test_search_file(self):
self.root.append_file('Shake.wav')
find = query_file('Shake.wav')['results']
assert_equal(len(find), 1)
def test_delete_file(self):
file_ = self.root.append_file('I\'ve Got Dreams To Remember.wav')
find = query_file('I\'ve Got Dreams To Remember.wav')['results']
assert_equal(len(find), 1)
file_.delete()
find = query_file('I\'ve Got Dreams To Remember.wav')['results']
assert_equal(len(find), 0)
def test_add_tag(self):
file_ = self.root.append_file('That\'s How Strong My Love Is.mp3')
tag = Tag(_id='Redding')
tag.save()
file_.tags.append(tag)
file_.save()
find = query_tag_file('Redding')['results']
assert_equal(len(find), 1)
def test_remove_tag(self):
file_ = self.root.append_file('I\'ve Been Loving You Too Long.mp3')
tag = Tag(_id='Blue')
tag.save()
file_.tags.append(tag)
file_.save()
find = query_tag_file('Blue')['results']
assert_equal(len(find), 1)
file_.tags.remove('Blue')
file_.save()
find = query_tag_file('Blue')['results']
assert_equal(len(find), 0)
def test_make_node_private(self):
file_ = self.root.append_file('Change_Gonna_Come.wav')
find = query_file('Change_Gonna_Come.wav')['results']
assert_equal(len(find), 1)
self.node.is_public = False
self.node.save()
find = query_file('Change_Gonna_Come.wav')['results']
assert_equal(len(find), 0)
def test_make_private_node_public(self):
self.node.is_public = False
self.node.save()
file_ = self.root.append_file('Try a Little Tenderness.flac')
find = query_file('Try a Little Tenderness.flac')['results']
assert_equal(len(find), 0)
self.node.is_public = True
self.node.save()
find = query_file('Try a Little Tenderness.flac')['results']
assert_equal(len(find), 1)
def test_delete_node(self):
node = ProjectFactory(is_public=True, title='The Soul Album')
osf_storage = node.get_addon('osfstorage')
root = osf_storage.get_root()
root.append_file('The Dock of the Bay.mp3')
find = query_file('The Dock of the Bay.mp3')['results']
assert_equal(len(find), 1)
node.is_deleted = True
node.save()
find = query_file('The Dock of the Bay.mp3')['results']
assert_equal(len(find), 0)
class TestAddonAuth(OsfTestCase):
def setUp(self):
super(TestAddonAuth, self).setUp()
self.flask_app = SetEnvironMiddleware(self.app.app, REMOTE_ADDR='127.0.0.1')
self.test_app = webtest.TestApp(self.flask_app)
self.user = AuthUserFactory()
self.auth_obj = Auth(user=self.user)
self.node = ProjectFactory(creator=self.user)
self.session = Session(data={'auth_user_id': self.user._id})
self.session.save()
self.cookie = itsdangerous.Signer(settings.SECRET_KEY).sign(self.session._id)
self.configure_addon()
def configure_addon(self):
self.user.add_addon('github')
self.user_addon = self.user.get_addon('github')
self.oauth_settings = AddonGitHubOauthSettings(github_user_id='john')
self.oauth_settings.save()
self.user_addon.oauth_settings = self.oauth_settings
self.user_addon.oauth_access_token = 'secret'
self.user_addon.save()
self.node.add_addon('github', self.auth_obj)
self.node_addon = self.node.get_addon('github')
self.node_addon.user = '******'
self.node_addon.repo = 'youre-my-best-friend'
self.node_addon.user_settings = self.user_addon
self.node_addon.save()
def build_url(self, **kwargs):
options = dict(
action='download',
cookie=self.cookie,
nid=self.node._id,
provider=self.node_addon.config.short_name,
)
options.update(kwargs)
return api_url_for('get_auth', **options)
def test_auth_download(self):
url = self.build_url()
res = self.test_app.get(url)
assert_equal(res.json['auth'], views.make_auth(self.user))
assert_equal(res.json['credentials'], self.node_addon.serialize_waterbutler_credentials())
assert_equal(res.json['settings'], self.node_addon.serialize_waterbutler_settings())
expected_url = furl.furl(self.node.api_url_for('create_waterbutler_log', _absolute=True))
observed_url = furl.furl(res.json['callback_url'])
observed_url.port = expected_url.port
assert_equal(expected_url, observed_url)
def test_auth_missing_args(self):
url = self.build_url(cookie=None)
res = self.test_app.get(url, expect_errors=True)
assert_equal(res.status_code, 400)
def test_auth_bad_cookie(self):
url = self.build_url(cookie=self.cookie[::-1])
res = self.test_app.get(url, expect_errors=True)
assert_equal(res.status_code, 401)
def test_auth_missing_addon(self):
url = self.build_url(provider='queenhub')
res = self.test_app.get(url, expect_errors=True)
assert_equal(res.status_code, 400)
def test_auth_bad_ip(self):
flask_app = SetEnvironMiddleware(self.app.app, REMOTE_ADDR='192.168.1.1')
test_app = webtest.TestApp(flask_app)
url = self.build_url()
res = test_app.get(url, expect_errors=True)
assert_equal(res.status_code, 403)
class TestCallbacks(OsfTestCase):
def setUp(self):
super(TestCallbacks, self).setUp()
self.user = AuthUserFactory()
self.consolidated_auth = Auth(user=self.user)
self.auth = self.user.auth
self.project = ProjectFactory(creator=self.user)
self.non_authenticator = AuthUserFactory()
self.project.add_contributor(
contributor=self.non_authenticator,
auth=Auth(self.project.creator),
)
self.project.add_addon('figshare', auth=self.consolidated_auth)
self.project.creator.add_addon('figshare')
self.node_settings = self.project.get_addon('figshare')
self.user_settings = self.project.creator.get_addon('figshare')
self.user_settings.oauth_access_token = 'legittoken'
self.user_settings.oauth_access_token_secret = 'legittoken'
self.user_settings.save()
self.node_settings.user_settings = self.user_settings
self.node_settings.figshare_id = '123456'
self.node_settings.figshare_type = 'project'
self.node_settings.figshare_title = 'singlefile'
self.node_settings.save()
def test_update_fields_project(self):
num_logs = len(self.project.logs)
# try updating fields
newfields = {'type': 'project', 'id': '313131', 'name': 'A PROJECT'}
self.node_settings.update_fields(newfields, self.project,
Auth(self.project.creator))
#check for updated
assert_equals(self.node_settings.figshare_id, '313131')
assert_equals(self.node_settings.figshare_type, 'project')
assert_equals(self.node_settings.figshare_title, 'A PROJECT')
# check for log added
assert_equals(len(self.project.logs), num_logs + 1)
def test_update_fields_fileset(self):
num_logs = len(self.project.logs)
# try updating fields
newfields = {'type': 'fileset', 'id': '313131', 'name': 'A FILESET'}
self.node_settings.update_fields(newfields, self.project,
Auth(self.project.creator))
#check for updated
assert_equals(self.node_settings.figshare_id, '313131')
assert_equals(self.node_settings.figshare_type, 'fileset')
assert_equals(self.node_settings.figshare_title, 'A FILESET')
# check for log added
assert_equals(len(self.project.logs), num_logs + 1)
def test_update_fields_some_missing(self):
num_logs = len(self.project.logs)
# try updating fields
newfields = {'type': 'project', 'id': '313131', 'name': 'A PROJECT'}
self.node_settings.update_fields(newfields, self.project,
Auth(self.project.creator))
#check for updated
assert_equals(self.node_settings.figshare_id, '313131')
assert_equals(self.node_settings.figshare_title, 'A PROJECT')
# check for log added
assert_equals(len(self.project.logs), num_logs + 1)
def test_update_fields_invalid(self):
num_logs = len(self.project.logs)
# try updating fields
newfields = {
'adad': 131313,
'i1513': '313131',
'titladad': 'A PROJECT'
}
self.node_settings.update_fields(newfields, self.project,
Auth(self.project.creator))
#check for updated
assert_equals(self.node_settings.figshare_id, '123456')
assert_equals(self.node_settings.figshare_type, 'project')
assert_equals(self.node_settings.figshare_title, 'singlefile')
# check for log added
assert_equals(len(self.project.logs), num_logs)
def test_api_url_no_user(self):
self.node_settings.user_settings = None
self.node_settings.save()
assert_equal(self.node_settings.api_url, figshare_settings.API_URL)
def test_api_url(self):
assert_equal(self.node_settings.api_url,
figshare_settings.API_OAUTH_URL)
def test_before_register_linked_content(self):
assert_false(
self.node_settings.before_register(self.project,
self.project.creator) is None)
def test_before_register_no_linked_content(self):
self.node_settings.figshare_id = None
assert_true(
self.node_settings.before_register(self.project,
self.project.creator) is None)
def test_before_remove_contributor_authenticator(self):
message = self.node_settings.before_remove_contributor(
self.project, self.project.creator)
assert_true(message)
def test_before_remove_contributor_not_authenticator(self):
message = self.node_settings.before_remove_contributor(
self.project, self.non_authenticator)
assert_false(message)
def test_after_remove_contributor_authenticator_not_self(self):
auth = Auth(user=self.non_authenticator)
msg = self.node_settings.after_remove_contributor(
self.project, self.project.creator, auth)
assert_in(self.project.project_or_component, msg)
assert_equal(self.node_settings.user_settings, None)
assert_in("You can re-authenticate", msg)
def test_after_remove_contributor_authenticator_self(self):
msg = self.node_settings.after_remove_contributor(
self.project, self.project.creator, self.consolidated_auth)
assert_in(self.project.title, msg)
assert_equal(self.node_settings.user_settings, None)
assert_not_in("You can re-authenticate", msg)
def test_after_fork_authenticator(self):
fork = ProjectFactory()
clone, message = self.node_settings.after_fork(
self.project,
fork,
self.project.creator,
)
assert_equal(
self.node_settings.user_settings,
clone.user_settings,
)
def test_after_fork_not_authenticator(self):
fork = ProjectFactory()
clone, message = self.node_settings.after_fork(
self.project,
fork,
self.non_authenticator,
)
assert_equal(
clone.user_settings,
None,
)
def test_after_delete(self):
self.project.remove_node(Auth(user=self.project.creator))
# Ensure that changes to node settings have been saved
self.node_settings.reload()
assert_true(self.node_settings.user_settings is None)
assert_true(self.node_settings.figshare_id is None)
assert_true(self.node_settings.figshare_type is None)
assert_true(self.node_settings.figshare_title is None)
@mock.patch('website.archiver.tasks.archive.si')
@mock.patch(
'website.addons.figshare.model.AddonFigShareNodeSettings.archive_errors'
)
def test_does_not_get_copied_to_registrations(self, mock_errors,
mock_archive):
registration = self.project.register_node(
schema=None,
auth=Auth(user=self.project.creator),
template='Template1',
data='hodor')
assert_false(registration.has_addon('figshare'))