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 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)
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 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 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 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')
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')
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 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 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)
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 TestMustHaveAddonDecorator(AuthAppTestCase):
def setUp(self):
super(TestMustHaveAddonDecorator, self).setUp()
self.project = ProjectFactory()
@mock.patch('website.project.decorators._kwargs_to_nodes')
def test_must_have_addon_node_true(self, mock_kwargs_to_nodes):
mock_kwargs_to_nodes.return_value = (self.project, None)
self.project.add_addon('github', auth=None)
decorated = must_have_addon('github', 'node')(needs_addon_view)
res = decorated()
assert_equal(res, 'openaddon')
@mock.patch('website.project.decorators._kwargs_to_nodes')
def test_must_have_addon_node_false(self, mock_kwargs_to_nodes):
mock_kwargs_to_nodes.return_value = (self.project, None)
decorated = must_have_addon('github', 'node')(needs_addon_view)
with assert_raises(HTTPError):
decorated()
@mock.patch('website.project.decorators.get_current_user')
def test_must_have_addon_user_true(self, mock_current_user):
mock_current_user.return_value = self.project.creator
self.project.creator.add_addon('github')
decorated = must_have_addon('github', 'user')(needs_addon_view)
res = decorated()
assert_equal(res, 'openaddon')
@mock.patch('website.project.decorators.get_current_user')
def test_must_have_addon_user_false(self, mock_current_user):
mock_current_user.return_value = self.project.creator
decorated = must_have_addon('github', 'user')(needs_addon_view)
with assert_raises(HTTPError):
decorated()
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)
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)
def test_migration(self):
GoogleDriveUserSettings.remove()
user = UserFactory()
node = ProjectFactory(creator=user)
account = GoogleDriveAccountFactory()
user.external_accounts = [account]
user.add_addon('googledrive', auth=Auth(user))
user_addon = user.get_addon('googledrive')
user_addon.save()
node.add_addon('googledrive', auth=Auth(user))
node_addon = node.get_addon('googledrive')
node_addon.foreign_user_settings = user_addon
node_addon.folder_id = 'abcdef0'
node_addon.folder_path = '/'
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 Google Drive)')
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 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)
def test_import_auth_invalid_account(self):
ea = self.ExternalAccountFactory()
node = ProjectFactory(creator=self.user)
node.add_addon(self.ADDON_SHORT_NAME, auth=self.auth)
node.save()
url = node.api_url_for("{0}_import_auth".format(self.ADDON_SHORT_NAME))
res = self.app.put_json(url, {"external_account_id": ea._id}, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, http.FORBIDDEN)
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 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_import_auth_invalid_account(self):
ea = self.ExternalAccountFactory()
node = ProjectFactory(creator=self.user)
node.add_addon(self.ADDON_SHORT_NAME, auth=self.auth)
node.save()
url = node.api_url_for('{0}_import_auth'.format(self.ADDON_SHORT_NAME))
res = self.app.put_json(url, {'external_account_id': ea._id},
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, http.FORBIDDEN)
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_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)
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)
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_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')
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 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_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)
def test_import_auth_cant_write_node(self):
ea = self.ExternalAccountFactory()
user = AuthUserFactory()
user.add_addon(self.ADDON_SHORT_NAME, auth=Auth(user))
user.external_accounts.append(ea)
user.save()
node = ProjectFactory(creator=self.user)
node.add_contributor(user, permissions=[permissions.READ], auth=self.auth, save=True)
node.add_addon(self.ADDON_SHORT_NAME, auth=self.auth)
node.save()
url = node.api_url_for("{0}_import_auth".format(self.ADDON_SHORT_NAME))
res = self.app.put_json(url, {"external_account_id": ea._id}, auth=user.auth, expect_errors=True)
assert_equal(res.status_code, http.FORBIDDEN)
class TestFileGuid(OsfTestCase):
def setUp(self):
super(OsfTestCase, self).setUp()
self.user = UserFactory()
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('s3', auth=Auth(self.user))
self.node_addon = self.project.get_addon('s3')
def test_provider(self):
assert_equal('s3', S3GuidFile().provider)
def test_correct_path(self):
guid = S3GuidFile(node=self.project, path='baz/foo/bar')
assert_equals(guid.path, 'baz/foo/bar')
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': {
'md5': 'Terran it up'
}
}
}
guid = S3GuidFile(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.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)
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 = UserFactory()
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('s3', auth=Auth(self.user))
self.node_addon = self.project.get_addon('s3')
def test_provider(self):
assert_equal('s3', S3GuidFile().provider)
def test_correct_path(self):
guid = S3GuidFile(node=self.project, path='baz/foo/bar')
assert_equals(guid.path, 'baz/foo/bar')
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': {
'md5': 'Terran it up'
}
}
}
guid = S3GuidFile(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.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)
class TestCRUD(OsfTestCase):
def setUp(self):
super(TestCRUD, self).setUp()
self.github = create_mock_github(user='******', private=False)
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_migration_no_account(self):
GoogleDriveUserSettings.remove()
user = UserFactory()
node = ProjectFactory(creator=user)
user.add_addon('googledrive', auth=Auth(user))
user_addon = user.get_addon('googledrive')
user_addon.save()
node.add_addon('googledrive', auth=Auth(user))
node_addon = node.get_addon('googledrive')
node_addon.foreign_user_settings = user_addon
node_addon.save()
do_migration() # Would raise exception if fail
def test_migration_no_account(self):
BoxUserSettings.remove()
user = UserFactory()
node = ProjectFactory(creator=user)
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.save()
do_migration() # Would raise exception if fail
def test_import_auth_cant_write_node(self):
ea = self.ExternalAccountFactory()
user = AuthUserFactory()
user.add_addon(self.ADDON_SHORT_NAME, auth=Auth(user))
user.external_accounts.append(ea)
user.save()
node = ProjectFactory(creator=self.user)
node.add_contributor(user, permissions=[permissions.READ], auth=self.auth, save=True)
node.add_addon(self.ADDON_SHORT_NAME, auth=self.auth)
node.save()
url = node.api_url_for('{0}_import_auth'.format(self.ADDON_SHORT_NAME))
res = self.app.put_json(url, {
'external_account_id': ea._id
}, auth=user.auth, expect_errors=True)
assert_equal(res.status_code, http.FORBIDDEN)
class TestCRUD(OsfTestCase):
def setUp(self):
super(TestCRUD, self).setUp()
self.github = create_mock_github(user='******', private=False)
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_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 TestHGridViews(OsfTestCase):
def setUp(self):
super(TestHGridViews, self).setUp()
self.github = create_mock_github(user='******', private=False)
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):
github_mock = self.github
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_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'])
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.external_account
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 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()
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)
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 AddonNodeLoggerTestSuiteMixinBase(object):
__metaclass__ = abc.ABCMeta
@abc.abstractproperty
def addon_short_name(self):
pass
@abc.abstractproperty
def NodeLogger(self):
pass
def setUp(self):
super(AddonNodeLoggerTestSuiteMixinBase, self).setUp()
self.auth = Auth(AuthUserFactory())
self.node = ProjectFactory(creator=self.auth.user)
self.path = None
self.node.add_addon(self.addon_short_name, auth=self.auth)
self.logger = self.NodeLogger(node=self.node, auth=self.auth)
class AddonNodeLoggerTestSuiteMixinBase(object):
__metaclass__ = abc.ABCMeta
@abc.abstractproperty
def addon_short_name(self):
pass
@abc.abstractproperty
def NodeLogger(self):
pass
def setUp(self):
super(AddonNodeLoggerTestSuiteMixinBase, self).setUp()
self.auth = Auth(AuthUserFactory())
self.node = ProjectFactory(creator=self.auth.user)
self.path = None
self.node.add_addon(self.addon_short_name, auth=self.auth)
self.logger = self.NodeLogger(node=self.node, auth=self.auth)
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)
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)
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)
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)
class TestMustHaveAddonDecorator(AuthAppTestCase):
def setUp(self):
super(TestMustHaveAddonDecorator, self).setUp()
self.project = ProjectFactory()
@mock.patch('website.project.decorators._kwargs_to_nodes')
def test_must_have_addon_node_true(self, mock_kwargs_to_nodes):
mock_kwargs_to_nodes.return_value = (None, self.project)
self.project.add_addon('github', auth=None)
decorated = must_have_addon('github', 'node')(needs_addon_view)
res = decorated()
assert_equal(res, 'openaddon')
@mock.patch('website.project.decorators._kwargs_to_nodes')
def test_must_have_addon_node_false(self, mock_kwargs_to_nodes):
mock_kwargs_to_nodes.return_value = (None, self.project)
self.project.delete_addon('github', auth=None)
decorated = must_have_addon('github', 'node')(needs_addon_view)
with assert_raises(HTTPError):
decorated()
@mock.patch('framework.auth.decorators.Auth.from_kwargs')
def test_must_have_addon_user_true(self, mock_current_user):
mock_current_user.return_value = Auth(self.project.creator)
self.project.creator.add_addon('github')
decorated = must_have_addon('github', 'user')(needs_addon_view)
res = decorated()
assert_equal(res, 'openaddon')
@mock.patch('framework.auth.decorators.Auth.from_kwargs')
def test_must_have_addon_user_false(self, mock_current_user):
mock_current_user.return_value = Auth(self.project.creator)
self.project.creator.delete_addon('github')
decorated = must_have_addon('github', 'user')(needs_addon_view)
with assert_raises(HTTPError):
decorated()
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 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()
