class ZoteroNodeSettingsTestCase(OsfTestCase):
def setUp(self):
super(ZoteroNodeSettingsTestCase, self).setUp()
self.node = ProjectFactory()
self.node_settings = model.ZoteroNodeSettings(owner=self.node)
self.node_settings.save()
self.user = self.node.creator
self.user_settings = self.user.get_or_add_addon('zotero')
def tearDown(self):
super(ZoteroNodeSettingsTestCase, self).tearDown()
self.user_settings.remove()
self.node_settings.remove()
self.node.remove()
self.user.remove()
@mock.patch('website.addons.zotero.model.Zotero')
def test_api_not_cached(self, mock_zotero):
# The first call to .api returns a new object
api = self.node_settings.api
mock_zotero.assert_called_once()
assert_equal(api, mock_zotero())
@mock.patch('website.addons.zotero.model.Zotero')
def test_api_cached(self, mock_zotero):
# Repeated calls to .api returns the same object
self.node_settings._api = 'testapi'
api = self.node_settings.api
assert_false(mock_zotero.called)
assert_equal(api, 'testapi')
def test_set_auth(self):
external_account = ZoteroAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
# this should be reset after the call
self.node_settings.zotero_list_id = 'anything'
self.node_settings.set_auth(
external_account=external_account,
user=self.user
)
# this instance is updated
assert_equal(
self.node_settings.external_account,
external_account
)
assert_equal(
self.node_settings.user_settings,
self.user_settings
)
assert_is_none(
self.node_settings.zotero_list_id
)
# user_settings was updated
# TODO: The call to grant_oauth_access in set_auth should be mocked
assert_true(
self.user_settings.verify_oauth_access(
node=self.node,
external_account=external_account,
)
)
def test_set_auth_wrong_user(self):
external_account = ZoteroAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
with assert_raises(PermissionsError):
self.node_settings.set_auth(
external_account=external_account,
user=UserFactory()
)
def test_deauthorize(self):
self.node_settings.external_account = ZoteroAccountFactory()
self.node_settings.zotero_list_id = 'something'
self.node_settings.user_settings = self.user_settings
self.node_settings.save()
assert_true(self.node_settings.zotero_list_id)
self.node_settings.deauthorize(auth=Auth(self.user))
self.node_settings.save()
assert_is(self.node_settings.user_settings, None)
assert_is(self.node_settings.zotero_list_id, None)
last_log = self.node.logs[-1]
assert_equal(last_log.action, 'zotero_node_deauthorized')
params = last_log.params
assert_in('node', params)
assert_in('project', params)
def test_clear_auth(self):
self.node_settings.external_account = ZoteroAccountFactory()
self.node_settings.zotero_list_id = 'something'
self.node_settings.user_settings = self.user_settings
self.node_settings.save()
self.node_settings.clear_auth()
assert_is_none(self.node_settings.external_account)
assert_is_none(self.node_settings.zotero_list_id)
assert_is_none(self.node_settings.user_settings)
def test_set_target_folder(self):
folder_id = 'fake-folder-id'
folder_name = 'fake-folder-name'
external_account = ZoteroAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
self.node_settings.set_auth(
external_account=external_account,
user=self.user
)
assert_is_none(self.node_settings.zotero_list_id)
self.node_settings.set_target_folder(
folder_id,
folder_name,
auth=Auth(user=self.user),
)
# instance was updated
assert_equal(
self.node_settings.zotero_list_id,
'fake-folder-id',
)
# user_settings was updated
# TODO: the call to grant_oauth_access should be mocked
assert_true(
self.user_settings.verify_oauth_access(
node=self.node,
external_account=external_account,
metadata={'folder': 'fake-folder-id'}
)
)
log = self.node.logs[-1]
assert_equal(log.action, 'zotero_folder_selected')
assert_equal(log.params['folder_id'], folder_id)
assert_equal(log.params['folder_name'], folder_name)
def test_has_auth_false(self):
external_account = ZoteroAccountFactory()
assert_false(self.node_settings.has_auth)
# both external_account and user_settings must be set to have auth
self.node_settings.external_account = external_account
assert_false(self.node_settings.has_auth)
self.node_settings.external_account = None
self.node_settings.user_settings = self.user_settings
assert_false(self.node_settings.has_auth)
# set_auth must be called to have auth
self.node_settings.external_account = external_account
self.node_settings.user_settings = self.user_settings
assert_false(self.node_settings.has_auth)
def test_has_auth_true(self):
external_account = ZoteroAccountFactory()
self.user.external_accounts.append(external_account)
self.node_settings.set_auth(external_account, self.user)
# zotero_list_id should have no effect
self.node_settings.zotero_list_id = None
assert_true(self.node_settings.has_auth)
# zotero_list_id should have no effect
self.node_settings.zotero_list_id = 'totally fake ID'
assert_true(self.node_settings.has_auth)
def test_selected_folder_name_root(self):
self.node_settings.zotero_list_id = 'ROOT'
assert_equal(
self.node_settings.selected_folder_name,
"All Documents"
)
def test_selected_folder_name_empty(self):
self.node_settings.zotero_list_id = None
assert_equal(
self.node_settings.selected_folder_name,
''
)
@mock.patch('website.addons.zotero.model.Zotero._folder_metadata')
def test_selected_folder_name(self, mock_folder_metadata):
# Mock the return from api call to get the folder's name
mock_folder = {'data': {'name': 'Fake Folder'}}
# Add the mocked return object to the mocked api client
mock_folder_metadata.return_value = mock_folder
self.node_settings.zotero_list_id = 'fake-list-id'
assert_equal(
self.node_settings.selected_folder_name,
'Fake Folder'
)
class MendeleyNodeSettingsTestCase(OsfTestCase):
def setUp(self):
super(MendeleyNodeSettingsTestCase, self).setUp()
self.node = ProjectFactory()
self.node_settings = model.MendeleyNodeSettings(owner=self.node)
self.node_settings.save()
self.user = self.node.creator
self.user_settings = self.user.get_or_add_addon('mendeley')
def tearDown(self):
super(MendeleyNodeSettingsTestCase, self).tearDown()
self.user_settings.remove()
self.node_settings.remove()
self.node.remove()
self.user.remove()
@mock.patch('website.addons.mendeley.model.Mendeley')
def test_api_not_cached(self, mock_mendeley):
# The first call to .api returns a new object
api = self.node_settings.api
mock_mendeley.assert_called_once()
assert_equal(api, mock_mendeley())
@mock.patch('website.addons.mendeley.model.Mendeley')
def test_api_cached(self, mock_mendeley):
# Repeated calls to .api returns the same object
self.node_settings._api = 'testapi'
api = self.node_settings.api
assert_false(mock_mendeley.called)
assert_equal(api, 'testapi')
def test_set_auth(self):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
# this should be reset after the call
self.node_settings.mendeley_list_id = 'anything'
self.node_settings.set_auth(
external_account=external_account,
user=self.user
)
# this instance is updated
assert_equal(
self.node_settings.external_account,
external_account
)
assert_equal(
self.node_settings.user_settings,
self.user_settings
)
assert_is_none(
self.node_settings.mendeley_list_id
)
# user_settings was updated
# TODO: The call to grant_oauth_access in set_auth should be mocked
assert_true(
self.user_settings.verify_oauth_access(
node=self.node,
external_account=external_account,
)
)
def test_set_auth_wrong_user(self):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
with assert_raises(PermissionsError):
self.node_settings.set_auth(
external_account=external_account,
user=UserFactory()
)
def test_clear_auth(self):
self.node_settings.external_account = ExternalAccountFactory()
self.node_settings.mendeley_list_id = 'something'
self.node_settings.user_settings = self.user_settings
self.node_settings.save()
self.node_settings.clear_auth()
assert_is_none(self.node_settings.external_account)
assert_is_none(self.node_settings.mendeley_list_id)
assert_is_none(self.node_settings.user_settings)
def test_set_target_folder(self):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
self.node_settings.set_auth(
external_account=external_account,
user=self.user
)
assert_is_none(self.node_settings.mendeley_list_id)
self.node_settings.set_target_folder('fake-folder-id')
# instance was updated
assert_equal(
self.node_settings.mendeley_list_id,
'fake-folder-id',
)
# user_settings was updated
# TODO: the call to grant_oauth_access should be mocked
assert_true(
self.user_settings.verify_oauth_access(
node=self.node,
external_account=external_account,
metadata={'folder': 'fake-folder-id'}
)
)
def test_has_auth_false(self):
external_account = ExternalAccountFactory()
assert_false(self.node_settings.has_auth)
# both external_account and user_settings must be set to have auth
self.node_settings.external_account = external_account
assert_false(self.node_settings.has_auth)
self.node_settings.external_account = None
self.node_settings.user_settings = self.user_settings
assert_false(self.node_settings.has_auth)
# set_auth must be called to have auth
self.node_settings.external_account = external_account
self.node_settings.user_settings = self.user_settings
assert_false(self.node_settings.has_auth)
def test_has_auth_true(self):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.node_settings.set_auth(external_account, self.user)
# mendeley_list_id should have no effect
self.node_settings.mendeley_list_id = None
assert_true(self.node_settings.has_auth)
# mendeley_list_id should have no effect
self.node_settings.mendeley_list_id = 'totally fake ID'
assert_true(self.node_settings.has_auth)
def test_selected_folder_name_root(self):
self.node_settings.mendeley_list_id = 'ROOT'
assert_equal(
self.node_settings.selected_folder_name,
"All Documents"
)
def test_selected_folder_name_empty(self):
self.node_settings.mendeley_list_id = None
assert_equal(
self.node_settings.selected_folder_name,
''
)
@mock.patch('website.addons.mendeley.model.Mendeley._folder_metadata')
def test_selected_folder_name(self, mock_folder_metadata):
# Mock the return from api call to get the folder's name
mock_folder = mock.Mock()
mock_folder.name = 'Fake Folder'
# Add the mocked return object to the mocked api client
mock_folder_metadata.return_value = mock_folder
self.node_settings.mendeley_list_id = 'fake-list-id'
assert_equal(
self.node_settings.selected_folder_name,
'Fake Folder'
)
class TestBoxNodeSettingsModel(OsfTestCase):
def setUp(self):
super(TestBoxNodeSettingsModel, self).setUp()
self.node = ProjectFactory()
self.user = self.node.creator
self.external_account = BoxAccountFactory()
self.user.add_addon('box')
self.user.external_accounts.append(self.external_account)
self.user.save()
self.user_settings = self.user.get_addon('box')
self.user_settings.grant_oauth_access(
node=self.node,
external_account=self.external_account,
metadata={'folder': 'fake_folder_id'}
)
self.user_settings.save()
self.node_settings = BoxNodeSettingsFactory(
user_settings=self.user_settings,
folder_id='1234567890',
owner=self.node
)
self.node_settings.external_account = self.external_account
self.node_settings.save()
def tearDown(self):
super(TestBoxNodeSettingsModel, self).tearDown()
self.user_settings.remove()
self.node_settings.remove()
self.external_account.remove()
self.node.remove()
self.user.remove()
def test_complete_true(self):
assert_true(self.node_settings.has_auth)
assert_true(self.node_settings.complete)
def test_complete_false(self):
self.user_settings.oauth_grants[self.node._id].pop(self.external_account._id)
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_fields(self):
node_settings = BoxNodeSettings(user_settings=self.user_settings)
node_settings.save()
assert_true(node_settings.user_settings)
assert_equal(node_settings.user_settings.owner, self.user)
assert_true(hasattr(node_settings, 'folder_id'))
assert_true(hasattr(node_settings, 'user_settings'))
def test_folder_defaults_to_none(self):
node_settings = BoxNodeSettings(user_settings=self.user_settings)
node_settings.save()
assert_is_none(node_settings.folder_id)
def test_has_auth(self):
self.user.external_accounts = []
self.user_settings.reload()
settings = BoxNodeSettings(user_settings=self.user_settings)
settings.save()
assert_false(settings.has_auth)
self.user.external_accounts.append(self.external_account)
settings.reload()
assert_true(settings.has_auth)
def test_clear_auth(self):
node_settings = BoxNodeSettingsFactory()
node_settings.external_account = BoxAccountFactory()
node_settings.user_settings = BoxUserSettingsFactory()
node_settings.save()
node_settings.clear_auth()
assert_is_none(node_settings.external_account)
assert_is_none(node_settings.folder_id)
assert_is_none(node_settings.user_settings)
def test_to_json(self):
settings = self.node_settings
user = UserFactory()
result = settings.to_json(user)
assert_equal(result['addon_short_name'], 'box')
def test_delete(self):
assert_true(self.node_settings.user_settings)
assert_true(self.node_settings.folder_id)
old_logs = self.node.logs
self.node_settings.delete()
self.node_settings.save()
assert_is(self.node_settings.user_settings, None)
assert_is(self.node_settings.folder_id, None)
assert_true(self.node_settings.deleted)
assert_equal(self.node.logs, old_logs)
def test_deauthorize(self):
assert_true(self.node_settings.user_settings)
assert_true(self.node_settings.folder_id)
self.node_settings.deauthorize(auth=Auth(self.user))
self.node_settings.save()
assert_is(self.node_settings.user_settings, None)
assert_is(self.node_settings.folder_id, None)
last_log = self.node.logs[-1]
assert_equal(last_log.action, 'box_node_deauthorized')
params = last_log.params
assert_in('node', params)
assert_in('project', params)
assert_in('folder_id', params)
@mock.patch("website.addons.box.model.BoxNodeSettings._update_folder_data")
def test_set_folder(self, mock_update_folder):
folder_id = '1234567890'
self.node_settings.set_folder(folder_id, auth=Auth(self.user))
self.node_settings.save()
# Folder was set
assert_equal(self.node_settings.folder_id, folder_id)
# Log was saved
last_log = self.node.logs[-1]
assert_equal(last_log.action, 'box_folder_selected')
def test_set_user_auth(self):
node_settings = BoxNodeSettingsFactory()
user_settings = BoxUserSettingsFactory()
external_account = BoxAccountFactory()
user_settings.owner.external_accounts.append(external_account)
user_settings.save()
node_settings.external_account = external_account
node_settings.set_user_auth(user_settings)
node_settings.save()
assert_true(node_settings.has_auth)
assert_equal(node_settings.user_settings, user_settings)
# A log was saved
last_log = node_settings.owner.logs[-1]
assert_equal(last_log.action, 'box_node_authorized')
log_params = last_log.params
assert_equal(log_params['folder_id'], node_settings.folder_id)
assert_equal(log_params['node'], node_settings.owner._primary_key)
assert_equal(last_log.user, user_settings.owner)
@mock.patch("website.addons.box.model.refresh_oauth_key")
def test_serialize_credentials(self, mock_refresh):
mock_refresh.return_value = True
self.user_settings.access_token = 'key-11'
self.user_settings.save()
credentials = self.node_settings.serialize_waterbutler_credentials()
expected = {'token': self.node_settings.user_settings.access_token}
assert_equal(credentials, expected)
def test_serialize_credentials_not_authorized(self):
self.node_settings.user_settings = None
self.node_settings.save()
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_credentials()
def test_serialize_settings(self):
settings = self.node_settings.serialize_waterbutler_settings()
expected = {'folder': self.node_settings.folder_id}
assert_equal(settings, expected)
def test_serialize_settings_not_configured(self):
self.node_settings.folder_id = None
self.node_settings.save()
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_settings()
def test_create_log(self):
action = 'file_added'
path = 'pizza.nii'
nlog = len(self.node.logs)
self.node_settings.create_waterbutler_log(
auth=Auth(user=self.user),
action=action,
metadata={'path': path, 'materialized': path},
)
self.node.reload()
assert_equal(len(self.node.logs), nlog + 1)
assert_equal(
self.node.logs[-1].action,
'box_{0}'.format(action),
)
assert_equal(
self.node.logs[-1].params['path'],
path
)
class TestGoogleDriveUserSettings(OsfTestCase):
def setUp(self):
super(TestGoogleDriveUserSettings, self).setUp()
self.node = ProjectFactory()
self.user = self.node.creator
self.external_account = GoogleDriveAccountFactory()
self.user.external_accounts.append(self.external_account)
self.user.save()
self.user_settings = self.user.get_or_add_addon('googledrive')
def tearDown(self):
super(TestGoogleDriveUserSettings, self).tearDown()
self.user_settings.remove()
self.external_account.remove()
self.node.remove()
self.user.remove()
def test_grant_oauth_access_no_metadata(self):
self.user_settings.grant_oauth_access(
node=self.node,
external_account=self.external_account,
)
self.user_settings.save()
assert_equal(
self.user_settings.oauth_grants,
{self.node._id: {
self.external_account._id: {}
}},
)
def test_grant_oauth_access_metadata(self):
self.user_settings.grant_oauth_access(
node=self.node,
external_account=self.external_account,
metadata={'folder': 'fake_folder_id'})
self.user_settings.save()
assert_equal(
self.user_settings.oauth_grants, {
self.node._id: {
self.external_account._id: {
'folder': 'fake_folder_id'
}
},
})
def test_verify_oauth_access_no_metadata(self):
self.user_settings.grant_oauth_access(
node=self.node,
external_account=self.external_account,
)
self.user_settings.save()
account_has_access = self.user_settings.verify_oauth_access(
node=self.node, external_account=self.external_account)
factory_account_has_access = self.user_settings.verify_oauth_access(
node=self.node, external_account=GoogleDriveAccountFactory())
assert_true(account_has_access)
assert_false(factory_account_has_access)
def test_verify_oauth_access_metadata(self):
self.user_settings.grant_oauth_access(
node=self.node,
external_account=self.external_account,
metadata={'folder': 'fake_folder_id'})
self.user_settings.save()
correct_meta_access = self.user_settings.verify_oauth_access(
node=self.node,
external_account=self.external_account,
metadata={'folder': 'fake_folder_id'})
incorrect_meta_no_access = self.user_settings.verify_oauth_access(
node=self.node,
external_account=self.external_account,
metadata={'folder': 'another_folder_id'})
assert_true(correct_meta_access)
assert_false(incorrect_meta_no_access)
class OAuthAddonNodeSettingsTestSuiteMixin(OAuthAddonModelTestSuiteMixinBase):
@abc.abstractproperty
def NodeSettingsFactory(self):
pass
@abc.abstractproperty
def NodeSettingsClass(self):
pass
@abc.abstractproperty
def UserSettingsFactory(self):
pass
def _node_settings_class_kwargs(self, node, user_settings):
return {
'user_settings': self.user_settings,
'folder_id': '1234567890',
'owner': self.node
}
def setUp(self):
super(OAuthAddonNodeSettingsTestSuiteMixin, self).setUp()
self.node = ProjectFactory()
self.user = self.node.creator
self.external_account = self.ExternalAccountFactory()
self.user.add_addon(self.short_name)
self.user.external_accounts.append(self.external_account)
self.user.save()
self.user_settings = self.user.get_addon(self.short_name)
self.user_settings.grant_oauth_access(
node=self.node,
external_account=self.external_account,
metadata={'folder': '1234567890'}
)
self.user_settings.save()
self.node_settings = self.NodeSettingsFactory(
**self._node_settings_class_kwargs(self.node, self.user_settings)
)
self.node_settings.external_account = self.external_account
self.node_settings.save()
def tearDown(self):
super(OAuthAddonNodeSettingsTestSuiteMixin, self).tearDown()
self.user_settings.remove()
self.node_settings.remove()
self.external_account.remove()
self.node.remove()
self.user.remove()
def test_complete_true(self):
assert_true(self.node_settings.has_auth)
assert_true(self.node_settings.complete)
def test_complete_has_auth_not_verified(self):
with mock_auth(self.user):
self.user_settings.revoke_oauth_access(self.external_account)
assert_false(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_fields(self):
node_settings = self.NodeSettingsClass(user_settings=self.user_settings)
node_settings.save()
assert_true(node_settings.user_settings)
assert_equal(node_settings.user_settings.owner, self.user)
assert_true(hasattr(node_settings, 'folder_id'))
assert_true(hasattr(node_settings, 'user_settings'))
def test_folder_defaults_to_none(self):
node_settings = self.NodeSettingsClass(user_settings=self.user_settings)
node_settings.save()
assert_is_none(node_settings.folder_id)
def test_has_auth(self):
self.user.external_accounts = []
self.user_settings.reload()
node = ProjectFactory()
settings = self.NodeSettingsClass(user_settings=self.user_settings, owner=node)
settings.save()
assert_false(settings.has_auth)
self.user.external_accounts.append(self.external_account)
settings.set_auth(self.external_account, self.user)
settings.reload()
assert_true(settings.has_auth)
def test_clear_auth(self):
node_settings = self.NodeSettingsFactory()
node_settings.external_account = self.ExternalAccountFactory()
node_settings.user_settings = self.UserSettingsFactory()
node_settings.save()
node_settings.clear_auth()
assert_is_none(node_settings.external_account)
assert_is_none(node_settings.user_settings)
def test_clear_settings(self):
node_settings = self.NodeSettingsFactory()
node_settings.external_account = self.ExternalAccountFactory()
node_settings.user_settings = self.UserSettingsFactory()
node_settings.save()
node_settings.clear_settings()
assert_is_none(node_settings.folder_id)
def test_to_json(self):
settings = self.node_settings
user = UserFactory()
result = settings.to_json(user)
assert_equal(result['addon_short_name'], self.short_name)
def test_delete(self):
assert_true(self.node_settings.user_settings)
assert_true(self.node_settings.folder_id)
old_logs = self.node.logs
self.node_settings.delete()
self.node_settings.save()
assert_is(self.node_settings.user_settings, None)
assert_is(self.node_settings.folder_id, None)
assert_true(self.node_settings.deleted)
assert_equal(self.node.logs, old_logs)
def test_deauthorize(self):
assert_true(self.node_settings.user_settings)
assert_true(self.node_settings.folder_id)
self.node_settings.deauthorize(auth=Auth(self.user))
self.node_settings.save()
assert_is(self.node_settings.user_settings, None)
assert_is(self.node_settings.folder_id, None)
last_log = self.node.logs[-1]
assert_equal(last_log.action, '{0}_node_deauthorized'.format(self.short_name))
params = last_log.params
assert_in('node', params)
assert_in('project', params)
def test_set_folder(self):
folder_id = '1234567890'
self.node_settings.set_folder(folder_id, auth=Auth(self.user))
self.node_settings.save()
# Folder was set
assert_equal(self.node_settings.folder_id, folder_id)
# Log was saved
last_log = self.node.logs[-1]
assert_equal(last_log.action, '{0}_folder_selected'.format(self.short_name))
def test_set_user_auth(self):
node_settings = self.NodeSettingsFactory()
user_settings = self.UserSettingsFactory()
external_account = self.ExternalAccountFactory()
user_settings.owner.external_accounts.append(external_account)
user_settings.save()
node_settings.external_account = external_account
node_settings.set_auth(external_account, user_settings.owner)
node_settings.save()
assert_true(node_settings.has_auth)
assert_equal(node_settings.user_settings, user_settings)
# A log was saved
last_log = node_settings.owner.logs[-1]
assert_equal(last_log.action, '{0}_node_authorized'.format(self.short_name))
log_params = last_log.params
assert_equal(log_params['node'], node_settings.owner._primary_key)
assert_equal(last_log.user, user_settings.owner)
def test_serialize_credentials(self):
self.user_settings.external_accounts[0].oauth_key = 'key-11'
self.user_settings.save()
credentials = self.node_settings.serialize_waterbutler_credentials()
expected = {'token': self.node_settings.external_account.oauth_key}
assert_equal(credentials, expected)
def test_serialize_credentials_not_authorized(self):
self.node_settings.user_settings = None
self.node_settings.save()
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_credentials()
def test_serialize_settings(self):
settings = self.node_settings.serialize_waterbutler_settings()
expected = {'folder': self.node_settings.folder_id}
assert_equal(settings, expected)
def test_serialize_settings_not_configured(self):
self.node_settings.clear_settings()
self.node_settings.save()
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_settings()
def test_create_log(self):
action = 'file_added'
path = 'pizza.nii'
nlog = len(self.node.logs)
self.node_settings.create_waterbutler_log(
auth=Auth(user=self.user),
action=action,
metadata={'path': path, 'materialized': path},
)
self.node.reload()
assert_equal(len(self.node.logs), nlog + 1)
assert_equal(
self.node.logs[-1].action,
'{0}_{1}'.format(self.short_name, action),
)
assert_equal(
self.node.logs[-1].params['path'],
path
)
def test_after_fork_by_authorized_user(self):
fork = ProjectFactory()
clone, message = self.node_settings.after_fork(
node=self.node, fork=fork, user=self.user_settings.owner
)
assert_equal(clone.user_settings, self.user_settings)
def test_after_fork_by_unauthorized_user(self):
fork = ProjectFactory()
user = UserFactory()
clone, message = self.node_settings.after_fork(
node=self.node, fork=fork, user=user,
save=True
)
assert_is(clone.user_settings, None)
def test_before_fork(self):
node = ProjectFactory()
message = self.node_settings.before_fork(node, self.user)
assert_true(message)
def test_before_remove_contributor_message(self):
message = self.node_settings.before_remove_contributor(
self.node, self.user)
assert_true(message)
assert_in(self.user.fullname, message)
assert_in(self.node.project_or_component, message)
def test_after_remove_authorized_user_not_self(self):
message = self.node_settings.after_remove_contributor(
self.node, self.user_settings.owner)
self.node_settings.save()
assert_is_none(self.node_settings.user_settings)
assert_true(message)
assert_in("You can re-authenticate", message)
def test_after_remove_authorized_user_self(self):
auth = Auth(user=self.user_settings.owner)
message = self.node_settings.after_remove_contributor(
self.node, self.user_settings.owner, auth)
self.node_settings.save()
assert_is_none(self.node_settings.user_settings)
assert_true(message)
assert_not_in("You can re-authenticate", message)
def test_after_delete(self):
self.node.remove_node(Auth(user=self.node.creator))
# Ensure that changes to node settings have been saved
self.node_settings.reload()
assert_is_none(self.node_settings.user_settings)
assert_is_none(self.node_settings.folder_id)
class ZoteroNodeSettingsTestCase(OsfTestCase):
def setUp(self):
super(ZoteroNodeSettingsTestCase, self).setUp()
self.node = ProjectFactory()
self.node_settings = model.ZoteroNodeSettings(owner=self.node)
self.node_settings.save()
self.user = self.node.creator
self.user_settings = self.user.get_or_add_addon('zotero')
def tearDown(self):
super(ZoteroNodeSettingsTestCase, self).tearDown()
self.user_settings.remove()
self.node_settings.remove()
self.node.remove()
self.user.remove()
@mock.patch('website.addons.zotero.model.Zotero')
def test_api_not_cached(self, mock_zotero):
# The first call to .api returns a new object
api = self.node_settings.api
mock_zotero.assert_called_once()
assert_equal(api, mock_zotero())
@mock.patch('website.addons.zotero.model.Zotero')
def test_api_cached(self, mock_zotero):
# Repeated calls to .api returns the same object
self.node_settings._api = 'testapi'
api = self.node_settings.api
assert_false(mock_zotero.called)
assert_equal(api, 'testapi')
def test_set_auth(self):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
# this should be reset after the call
self.node_settings.zotero_list_id = 'anything'
self.node_settings.set_auth(external_account=external_account,
user=self.user)
# this instance is updated
assert_equal(self.node_settings.external_account, external_account)
assert_equal(self.node_settings.user_settings, self.user_settings)
assert_is_none(self.node_settings.zotero_list_id)
# user_settings was updated
# TODO: The call to grant_oauth_access in set_auth should be mocked
assert_true(
self.user_settings.verify_oauth_access(
node=self.node,
external_account=external_account,
))
def test_set_auth_wrong_user(self):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
with assert_raises(PermissionsError):
self.node_settings.set_auth(external_account=external_account,
user=UserFactory())
def test_clear_auth(self):
self.node_settings.external_account = ExternalAccountFactory()
self.node_settings.zotero_list_id = 'something'
self.node_settings.user_settings = self.user_settings
self.node_settings.save()
self.node_settings.clear_auth()
assert_is_none(self.node_settings.external_account)
assert_is_none(self.node_settings.zotero_list_id)
assert_is_none(self.node_settings.user_settings)
def test_set_target_folder(self):
folder_id = 'fake-folder-id'
folder_name = 'fake-folder-name'
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
self.node_settings.set_auth(external_account=external_account,
user=self.user)
assert_is_none(self.node_settings.zotero_list_id)
self.node_settings.set_target_folder(
folder_id,
folder_name,
auth=Auth(user=self.user),
)
# instance was updated
assert_equal(
self.node_settings.zotero_list_id,
'fake-folder-id',
)
# user_settings was updated
# TODO: the call to grant_oauth_access should be mocked
assert_true(
self.user_settings.verify_oauth_access(
node=self.node,
external_account=external_account,
metadata={'folder': 'fake-folder-id'}))
log = self.node.logs[-1]
assert_equal(log.action, 'zotero_folder_selected')
assert_equal(log.params['folder_id'], folder_id)
assert_equal(log.params['folder_name'], folder_name)
def test_has_auth_false(self):
external_account = ExternalAccountFactory()
assert_false(self.node_settings.has_auth)
# both external_account and user_settings must be set to have auth
self.node_settings.external_account = external_account
assert_false(self.node_settings.has_auth)
self.node_settings.external_account = None
self.node_settings.user_settings = self.user_settings
assert_false(self.node_settings.has_auth)
# set_auth must be called to have auth
self.node_settings.external_account = external_account
self.node_settings.user_settings = self.user_settings
assert_false(self.node_settings.has_auth)
def test_has_auth_true(self):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.node_settings.set_auth(external_account, self.user)
# zotero_list_id should have no effect
self.node_settings.zotero_list_id = None
assert_true(self.node_settings.has_auth)
# zotero_list_id should have no effect
self.node_settings.zotero_list_id = 'totally fake ID'
assert_true(self.node_settings.has_auth)
def test_selected_folder_name_root(self):
self.node_settings.zotero_list_id = 'ROOT'
assert_equal(self.node_settings.selected_folder_name, "All Documents")
def test_selected_folder_name_empty(self):
self.node_settings.zotero_list_id = None
assert_equal(self.node_settings.selected_folder_name, '')
@mock.patch('website.addons.zotero.model.Zotero._folder_metadata')
def test_selected_folder_name(self, mock_folder_metadata):
# Mock the return from api call to get the folder's name
mock_folder = {'data': {'name': 'Fake Folder'}}
# Add the mocked return object to the mocked api client
mock_folder_metadata.return_value = mock_folder
self.node_settings.zotero_list_id = 'fake-list-id'
assert_equal(self.node_settings.selected_folder_name, 'Fake Folder')
class TestGoogleDriveNodeSettings(OsfTestCase):
def setUp(self):
super(TestGoogleDriveNodeSettings, self).setUp()
self.node = ProjectFactory()
self.node_settings = model.GoogleDriveNodeSettings(owner=self.node)
self.node_settings.save()
self.user = self.node.creator
self.user_settings = self.user.get_or_add_addon('googledrive')
def tearDown(self):
super(TestGoogleDriveNodeSettings, self).tearDown()
self.user_settings.remove()
self.node_settings.remove()
self.node.remove()
self.user.remove()
@mock.patch('website.addons.googledrive.model.GoogleDriveProvider')
def test_api_not_cached(self, mock_gdp):
# The first call to .api returns a new object
api = self.node_settings.api
mock_gdp.assert_called_once()
assert_equal(api, mock_gdp())
@mock.patch('website.addons.googledrive.model.GoogleDriveProvider')
def test_api_cached(self, mock_gdp):
# Repeated calls to .api returns the same object
self.node_settings._api = 'testapi'
api = self.node_settings.api
assert_false(mock_gdp.called)
assert_equal(api, 'testapi')
def test_set_auth(self):
external_account = GoogleDriveAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
# this should be reset after the call
self.node_settings.folder_id = 'anything'
self.node_settings.set_auth(external_account=external_account,
user=self.user)
# this instance is updated
assert_equal(self.node_settings.external_account, external_account)
assert_equal(self.node_settings.user_settings, self.user_settings)
assert_is_none(self.node_settings.folder_id)
set_auth_gives_access = self.user_settings.verify_oauth_access(
node=self.node,
external_account=external_account,
)
assert_true(set_auth_gives_access)
def test_set_auth_wrong_user(self):
external_account = GoogleDriveAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
with assert_raises(PermissionsError):
self.node_settings.set_auth(external_account=external_account,
user=UserFactory())
def test_clear_auth(self):
self.node_settings.external_account = GoogleDriveAccountFactory()
self.node_settings.folder_id = 'something'
self.node_settings.user_settings = self.user_settings
self.node_settings.save()
self.node_settings.clear_auth()
assert_is_none(self.node_settings.external_account)
assert_is_none(self.node_settings.folder_id)
assert_is_none(self.node_settings.user_settings)
assert_is_none(self.node_settings.folder_path)
assert_is_none(self.node_settings.folder_name)
def test_set_target_folder(self):
folder = {
'id': 'fake-folder-id',
'name': 'fake-folder-name',
'path': 'fake_path'
}
external_account = GoogleDriveAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
self.node_settings.set_auth(
external_account=external_account,
user=self.user,
)
assert_is_none(self.node_settings.folder_id)
self.node_settings.set_target_folder(
folder,
auth=Auth(user=self.user),
)
# instance was updated
assert_equal(
self.node_settings.folder_id,
'fake-folder-id',
)
has_access = self.user_settings.verify_oauth_access(
node=self.node,
external_account=external_account,
metadata={'folder': 'fake-folder-id'})
# user_settings was updated
assert_true(has_access)
log = self.node.logs[-1]
assert_equal(log.action, 'googledrive_folder_selected')
assert_equal(log.params['folder'], folder['path'])
def test_has_auth_false(self):
external_account = GoogleDriveAccountFactory()
assert_false(self.node_settings.has_auth)
# both external_account and user_settings must be set to have auth
self.node_settings.external_account = external_account
assert_false(self.node_settings.has_auth)
self.node_settings.external_account = None
self.node_settings.user_settings = self.user_settings
assert_false(self.node_settings.has_auth)
# set_auth must be called to have auth
self.node_settings.external_account = external_account
self.node_settings.user_settings = self.user_settings
assert_false(self.node_settings.has_auth)
def test_has_auth_true(self):
external_account = GoogleDriveAccountFactory()
self.user.external_accounts.append(external_account)
self.node_settings.set_auth(external_account, self.user)
self.node_settings.folder_id = None
assert_true(self.node_settings.has_auth)
self.node_settings.folder_id = 'totally fake ID'
assert_true(self.node_settings.has_auth)
def test_selected_folder_name_root(self):
self.node_settings.folder_id = 'root'
assert_equal(self.node_settings.selected_folder_name,
"Full Google Drive")
def test_selected_folder_name_empty(self):
self.node_settings.folder_id = None
assert_equal(self.node_settings.selected_folder_name, '')
def test_selected_folder_name(self):
self.node_settings.folder_id = 'fake-id'
self.node_settings.folder_path = 'fake-folder-name'
self.node_settings.save()
assert_equal(self.node_settings.selected_folder_name,
'fake-folder-name')
@mock.patch(
'website.addons.googledrive.model.GoogleDriveProvider.refresh_oauth_key'
)
def test_serialize_credentials(self, mock_refresh):
mock_refresh.return_value = True
external_account = GoogleDriveAccountFactory()
self.user.external_accounts.append(external_account)
self.node_settings.set_auth(external_account, self.user)
credentials = self.node_settings.serialize_waterbutler_credentials()
expected = {'token': self.node_settings.fetch_access_token()}
assert_equal(credentials, expected)
@mock.patch(
'website.addons.googledrive.model.GoogleDriveProvider.refresh_oauth_key'
)
def test_serialize_credentials_not_authorized(self, mock_refresh):
mock_refresh.return_value = True
external_account = GoogleDriveAccountFactory()
self.node_settings.external_account = external_account
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_credentials()
def test_serialize_settings(self):
self.node_settings.folder_id = 'fake-id'
self.node_settings.folder_path = 'fake-folder-name'
self.node_settings.save()
settings = self.node_settings.serialize_waterbutler_settings()
expected = {
'folder': {
'id': 'fake-id',
'name': 'fake-folder-name',
'path': 'fake-folder-name',
}
}
assert_equal(settings, expected)
def test_serialize_settings_not_configured(self):
self.node_settings.folder_id = None
self.node_settings.save()
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_settings()
def test_fetch_access_token_with_token_not_expired(self):
external_account = GoogleDriveAccountFactory()
self.user.external_accounts.append(external_account)
external_account.expires_at = datetime.utcnow(
) + relativedelta.relativedelta(minutes=6)
external_account.oauth_key = 'fake-token'
external_account.save()
self.node_settings.set_auth(external_account, self.user)
assert_equal(self.node_settings.fetch_access_token(), 'fake-token')
class MendeleyNodeSettingsTestCase(OsfTestCase):
def setUp(self):
super(MendeleyNodeSettingsTestCase, self).setUp()
self.node = ProjectFactory()
self.node_settings = model.MendeleyNodeSettings(owner=self.node)
self.node_settings.save()
self.user = self.node.creator
self.user_settings = self.user.get_or_add_addon('mendeley')
def tearDown(self):
super(MendeleyNodeSettingsTestCase, self).tearDown()
self.user_settings.remove()
self.node_settings.remove()
self.node.remove()
self.user.remove()
@mock.patch('website.addons.mendeley.model.Mendeley')
def test_api_not_cached(self, mock_mendeley):
# The first call to .api returns a new object
api = self.node_settings.api
mock_mendeley.assert_called_once()
assert_equal(api, mock_mendeley())
@mock.patch('website.addons.mendeley.model.Mendeley')
def test_api_cached(self, mock_mendeley):
# Repeated calls to .api returns the same object
self.node_settings._api = 'testapi'
api = self.node_settings.api
assert_false(mock_mendeley.called)
assert_equal(api, 'testapi')
def test_set_auth(self):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
# this should be reset after the call
self.node_settings.mendeley_list_id = 'anything'
self.node_settings.set_auth(
external_account=external_account,
user=self.user
)
# this instance is updated
assert_equal(
self.node_settings.external_account,
external_account
)
assert_equal(
self.node_settings.user_settings,
self.user_settings
)
assert_is_none(
self.node_settings.mendeley_list_id
)
# user_settings was updated
# TODO: The call to grant_oauth_access in set_auth should be mocked
assert_true(
self.user_settings.verify_oauth_access(
node=self.node,
external_account=external_account,
)
)
def test_set_auth_wrong_user(self):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
with assert_raises(PermissionsError):
self.node_settings.set_auth(
external_account=external_account,
user=UserFactory()
)
def test_deauthorize(self):
self.node_settings.external_account = ExternalAccountFactory()
self.node_settings.mendeley_list_id = 'something'
self.node_settings.user_settings = self.user_settings
self.node_settings.save()
assert_true(self.node_settings.mendeley_list_id)
self.node_settings.deauthorize(auth=Auth(self.user))
self.node_settings.save()
assert_is(self.node_settings.user_settings, None)
assert_is(self.node_settings.mendeley_list_id, None)
last_log = self.node.logs[-1]
assert_equal(last_log.action, 'mendeley_node_deauthorized')
params = last_log.params
assert_in('node', params)
assert_in('project', params)
def test_clear_auth(self):
self.node_settings.external_account = ExternalAccountFactory()
self.node_settings.mendeley_list_id = 'something'
self.node_settings.user_settings = self.user_settings
self.node_settings.save()
self.node_settings.clear_auth()
assert_is_none(self.node_settings.external_account)
assert_is_none(self.node_settings.mendeley_list_id)
assert_is_none(self.node_settings.user_settings)
def test_set_target_folder(self):
folder_id = 'fake-folder-id'
folder_name = 'fake-folder-name'
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
self.node_settings.set_auth(
external_account=external_account,
user=self.user,
)
assert_is_none(self.node_settings.mendeley_list_id)
self.node_settings.set_target_folder(
folder_id,
folder_name,
auth=Auth(user=self.user),
)
# instance was updated
assert_equal(
self.node_settings.mendeley_list_id,
'fake-folder-id',
)
# user_settings was updated
# TODO: the call to grant_oauth_access should be mocked
assert_true(
self.user_settings.verify_oauth_access(
node=self.node,
external_account=external_account,
metadata={'folder': 'fake-folder-id'}
)
)
log = self.node.logs[-1]
assert_equal(log.action, 'mendeley_folder_selected')
assert_equal(log.params['folder_id'], folder_id)
assert_equal(log.params['folder_name'], folder_name)
def test_has_auth_false(self):
external_account = ExternalAccountFactory()
assert_false(self.node_settings.has_auth)
# both external_account and user_settings must be set to have auth
self.node_settings.external_account = external_account
assert_false(self.node_settings.has_auth)
self.node_settings.external_account = None
self.node_settings.user_settings = self.user_settings
assert_false(self.node_settings.has_auth)
# set_auth must be called to have auth
self.node_settings.external_account = external_account
self.node_settings.user_settings = self.user_settings
assert_false(self.node_settings.has_auth)
def test_has_auth_true(self):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.node_settings.set_auth(external_account, self.user)
# mendeley_list_id should have no effect
self.node_settings.mendeley_list_id = None
assert_true(self.node_settings.has_auth)
# mendeley_list_id should have no effect
self.node_settings.mendeley_list_id = 'totally fake ID'
assert_true(self.node_settings.has_auth)
def test_selected_folder_name_root(self):
self.node_settings.mendeley_list_id = 'ROOT'
assert_equal(
self.node_settings.selected_folder_name,
"All Documents"
)
def test_selected_folder_name_empty(self):
self.node_settings.mendeley_list_id = None
assert_equal(
self.node_settings.selected_folder_name,
''
)
@mock.patch('website.addons.mendeley.model.Mendeley._folder_metadata')
def test_selected_folder_name(self, mock_folder_metadata):
# Mock the return from api call to get the folder's name
mock_folder = mock.Mock()
mock_folder.name = 'Fake Folder'
# Add the mocked return object to the mocked api client
mock_folder_metadata.return_value = mock_folder
self.node_settings.mendeley_list_id = 'fake-list-id'
assert_equal(
self.node_settings.selected_folder_name,
'Fake Folder'
)
# TODO: Make these tests generic and move to core
@mock.patch('framework.status.push_status_message')
def test_remove_contributor_authorizer(self, mock_push_status):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.node_settings.set_auth(external_account, self.user)
contributor = UserFactory()
self.node.add_contributor(contributor, permissions=['read', 'write', 'admin'])
self.node.remove_contributor(self.node.creator, auth=Auth(user=contributor))
assert_false(self.node_settings.has_auth)
assert_false(self.user_settings.verify_oauth_access(self.node, external_account))
def test_remove_contributor_not_authorizer(self):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.node_settings.set_auth(external_account, self.user)
contributor = UserFactory()
self.node.add_contributor(contributor)
self.node.remove_contributor(contributor, auth=Auth(user=self.node.creator))
assert_true(self.node_settings.has_auth)
assert_true(self.user_settings.verify_oauth_access(self.node, external_account))
@mock.patch('framework.status.push_status_message')
def test_fork_by_authorizer(self, mock_push_status):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.node_settings.set_auth(external_account, self.user)
fork = self.node.fork_node(auth=Auth(user=self.node.creator))
assert_true(fork.get_addon('mendeley').has_auth)
assert_true(self.user_settings.verify_oauth_access(fork, external_account))
@mock.patch('framework.status.push_status_message')
def test_fork_not_by_authorizer(self, mock_push_status):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.node_settings.set_auth(external_account, self.user)
contributor = UserFactory()
self.node.add_contributor(contributor)
fork = self.node.fork_node(auth=Auth(user=contributor))
assert_false(fork.get_addon('mendeley').has_auth)
assert_false(self.user_settings.verify_oauth_access(fork, external_account))
class OAuthAddonNodeSettingsTestSuiteMixin(OAuthAddonModelTestSuiteMixinBase):
@abc.abstractproperty
def NodeSettingsFactory(self):
pass
@abc.abstractproperty
def NodeSettingsClass(self):
pass
@abc.abstractproperty
def UserSettingsFactory(self):
pass
def _node_settings_class_kwargs(self, node, user_settings):
return {
'user_settings': self.user_settings,
'folder_id': '1234567890',
'owner': self.node
}
def setUp(self):
super(OAuthAddonNodeSettingsTestSuiteMixin, self).setUp()
self.node = ProjectFactory()
self.user = self.node.creator
self.external_account = self.ExternalAccountFactory()
self.user.add_addon(self.short_name)
self.user.external_accounts.append(self.external_account)
self.user.save()
self.user_settings = self.user.get_addon(self.short_name)
self.user_settings.grant_oauth_access(
node=self.node,
external_account=self.external_account,
metadata={'folder': '1234567890'}
)
self.user_settings.save()
self.node_settings = self.NodeSettingsFactory(
**self._node_settings_class_kwargs(self.node, self.user_settings)
)
self.node_settings.external_account = self.external_account
self.node_settings.save()
def tearDown(self):
super(OAuthAddonNodeSettingsTestSuiteMixin, self).tearDown()
self.user_settings.remove()
self.node_settings.remove()
self.external_account.remove()
self.node.remove()
self.user.remove()
def test_complete_true(self):
assert_true(self.node_settings.has_auth)
assert_true(self.node_settings.complete)
def test_complete_has_auth_not_verified(self):
with mock_auth(self.user):
self.user_settings.revoke_oauth_access(self.external_account)
assert_false(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_fields(self):
node_settings = self.NodeSettingsClass(user_settings=self.user_settings)
node_settings.save()
assert_true(node_settings.user_settings)
assert_equal(node_settings.user_settings.owner, self.user)
assert_true(hasattr(node_settings, 'folder_id'))
assert_true(hasattr(node_settings, 'user_settings'))
def test_folder_defaults_to_none(self):
node_settings = self.NodeSettingsClass(user_settings=self.user_settings)
node_settings.save()
assert_is_none(node_settings.folder_id)
def test_has_auth(self):
self.user.external_accounts = []
self.user_settings.reload()
node = ProjectFactory()
settings = self.NodeSettingsClass(user_settings=self.user_settings, owner=node)
settings.save()
assert_false(settings.has_auth)
self.user.external_accounts.append(self.external_account)
settings.set_auth(self.external_account, self.user)
settings.reload()
assert_true(settings.has_auth)
def test_clear_auth(self):
node_settings = self.NodeSettingsFactory()
node_settings.external_account = self.ExternalAccountFactory()
node_settings.user_settings = self.UserSettingsFactory()
node_settings.save()
node_settings.clear_auth()
assert_is_none(node_settings.external_account)
assert_is_none(node_settings.user_settings)
def test_clear_settings(self):
node_settings = self.NodeSettingsFactory()
node_settings.external_account = self.ExternalAccountFactory()
node_settings.user_settings = self.UserSettingsFactory()
node_settings.save()
node_settings.clear_settings()
assert_is_none(node_settings.folder_id)
def test_to_json(self):
settings = self.node_settings
user = UserFactory()
result = settings.to_json(user)
assert_equal(result['addon_short_name'], self.short_name)
def test_delete(self):
assert_true(self.node_settings.user_settings)
assert_true(self.node_settings.folder_id)
old_logs = self.node.logs
self.node_settings.delete()
self.node_settings.save()
assert_is(self.node_settings.user_settings, None)
assert_is(self.node_settings.folder_id, None)
assert_true(self.node_settings.deleted)
assert_equal(self.node.logs, old_logs)
def test_deauthorize(self):
assert_true(self.node_settings.user_settings)
assert_true(self.node_settings.folder_id)
self.node_settings.deauthorize(auth=Auth(self.user))
self.node_settings.save()
assert_is(self.node_settings.user_settings, None)
assert_is(self.node_settings.folder_id, None)
last_log = self.node.logs[-1]
assert_equal(last_log.action, '{0}_node_deauthorized'.format(self.short_name))
params = last_log.params
assert_in('node', params)
assert_in('project', params)
def test_set_folder(self):
folder_id = '1234567890'
self.node_settings.set_folder(folder_id, auth=Auth(self.user))
self.node_settings.save()
# Folder was set
assert_equal(self.node_settings.folder_id, folder_id)
# Log was saved
last_log = self.node.logs[-1]
assert_equal(last_log.action, '{0}_folder_selected'.format(self.short_name))
def test_set_user_auth(self):
node_settings = self.NodeSettingsFactory()
user_settings = self.UserSettingsFactory()
external_account = self.ExternalAccountFactory()
user_settings.owner.external_accounts.append(external_account)
user_settings.save()
node_settings.external_account = external_account
node_settings.set_auth(external_account, user_settings.owner)
node_settings.save()
assert_true(node_settings.has_auth)
assert_equal(node_settings.user_settings, user_settings)
# A log was saved
last_log = node_settings.owner.logs[-1]
assert_equal(last_log.action, '{0}_node_authorized'.format(self.short_name))
log_params = last_log.params
assert_equal(log_params['node'], node_settings.owner._primary_key)
assert_equal(last_log.user, user_settings.owner)
def test_serialize_credentials(self):
self.user_settings.external_accounts[0].oauth_key = 'key-11'
self.user_settings.save()
credentials = self.node_settings.serialize_waterbutler_credentials()
expected = {'token': self.node_settings.external_account.oauth_key}
assert_equal(credentials, expected)
def test_serialize_credentials_not_authorized(self):
self.node_settings.user_settings = None
self.node_settings.save()
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_credentials()
def test_serialize_settings(self):
settings = self.node_settings.serialize_waterbutler_settings()
expected = {'folder': self.node_settings.folder_id}
assert_equal(settings, expected)
def test_serialize_settings_not_configured(self):
self.node_settings.clear_settings()
self.node_settings.save()
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_settings()
def test_create_log(self):
action = 'file_added'
path = 'pizza.nii'
nlog = len(self.node.logs)
self.node_settings.create_waterbutler_log(
auth=Auth(user=self.user),
action=action,
metadata={'path': path, 'materialized': path},
)
self.node.reload()
assert_equal(len(self.node.logs), nlog + 1)
assert_equal(
self.node.logs[-1].action,
'{0}_{1}'.format(self.short_name, action),
)
assert_equal(
self.node.logs[-1].params['path'],
path
)
def test_after_fork_by_authorized_user(self):
fork = ProjectFactory()
clone, message = self.node_settings.after_fork(
node=self.node, fork=fork, user=self.user_settings.owner
)
assert_equal(clone.user_settings, self.user_settings)
def test_after_fork_by_unauthorized_user(self):
fork = ProjectFactory()
user = UserFactory()
clone, message = self.node_settings.after_fork(
node=self.node, fork=fork, user=user,
save=True
)
assert_is(clone.user_settings, None)
def test_before_fork(self):
node = ProjectFactory()
message = self.node_settings.before_fork(node, self.user)
assert_true(message)
def test_before_remove_contributor_message(self):
message = self.node_settings.before_remove_contributor(
self.node, self.user)
assert_true(message)
assert_in(self.user.fullname, message)
assert_in(self.node.project_or_component, message)
def test_after_remove_authorized_user_not_self(self):
message = self.node_settings.after_remove_contributor(
self.node, self.user_settings.owner)
self.node_settings.save()
assert_is_none(self.node_settings.user_settings)
assert_true(message)
assert_in("You can re-authenticate", message)
def test_after_remove_authorized_user_self(self):
auth = Auth(user=self.user_settings.owner)
message = self.node_settings.after_remove_contributor(
self.node, self.user_settings.owner, auth)
self.node_settings.save()
assert_is_none(self.node_settings.user_settings)
assert_true(message)
assert_not_in("You can re-authenticate", message)
def test_after_delete(self):
self.node.remove_node(Auth(user=self.node.creator))
# Ensure that changes to node settings have been saved
self.node_settings.reload()
assert_is_none(self.node_settings.user_settings)
assert_is_none(self.node_settings.folder_id)
class TestGoogleDriveUserSettings(OsfTestCase):
def setUp(self):
super(TestGoogleDriveUserSettings, self).setUp()
self.node = ProjectFactory()
self.user = self.node.creator
self.external_account = GoogleDriveAccountFactory()
self.user.external_accounts.append(self.external_account)
self.user.save()
self.user_settings = self.user.get_or_add_addon('googledrive')
def tearDown(self):
super(TestGoogleDriveUserSettings, self).tearDown()
self.user_settings.remove()
self.external_account.remove()
self.node.remove()
self.user.remove()
def test_grant_oauth_access_no_metadata(self):
self.user_settings.grant_oauth_access(
node=self.node,
external_account=self.external_account,
)
self.user_settings.save()
assert_equal(
self.user_settings.oauth_grants,
{self.node._id: {self.external_account._id: {}}},
)
def test_grant_oauth_access_metadata(self):
self.user_settings.grant_oauth_access(
node=self.node,
external_account=self.external_account,
metadata={'folder': 'fake_folder_id'}
)
self.user_settings.save()
assert_equal(
self.user_settings.oauth_grants,
{
self.node._id: {
self.external_account._id: {'folder': 'fake_folder_id'}
},
}
)
def test_verify_oauth_access_no_metadata(self):
self.user_settings.grant_oauth_access(
node=self.node,
external_account=self.external_account,
)
self.user_settings.save()
account_has_access = self.user_settings.verify_oauth_access(
node=self.node,
external_account=self.external_account
)
factory_account_has_access = self.user_settings.verify_oauth_access(
node=self.node,
external_account=GoogleDriveAccountFactory()
)
assert_true(account_has_access)
assert_false(factory_account_has_access)
def test_verify_oauth_access_metadata(self):
self.user_settings.grant_oauth_access(
node=self.node,
external_account=self.external_account,
metadata={'folder': 'fake_folder_id'}
)
self.user_settings.save()
correct_meta_access = self.user_settings.verify_oauth_access(
node=self.node,
external_account=self.external_account,
metadata={'folder': 'fake_folder_id'}
)
incorrect_meta_no_access = self.user_settings.verify_oauth_access(
node=self.node,
external_account=self.external_account,
metadata={'folder': 'another_folder_id'}
)
assert_true(correct_meta_access)
assert_false(incorrect_meta_no_access)
class ApiAddonTestCase(ApiTestCase):
"""Base `TestCase` for tests that require interaction with addons.
"""
@abc.abstractproperty
def short_name(self):
pass
@abc.abstractproperty
def addon_type(self):
pass
@abc.abstractmethod
def _apply_auth_configuration(self):
pass
@abc.abstractmethod
def _set_urls(self):
pass
def _settings_kwargs(self, node, user_settings):
return {"user_settings": self.user_settings, "folder_id": "1234567890", "owner": self.node}
def setUp(self):
super(ApiAddonTestCase, self).setUp()
from tests.factories import ProjectFactory, AuthUserFactory
from website.addons.base import (
AddonOAuthNodeSettingsBase,
AddonNodeSettingsBase,
AddonOAuthUserSettingsBase,
AddonUserSettingsBase,
)
assert self.addon_type in ("CONFIGURABLE", "OAUTH", "UNMANAGEABLE", "INVALID")
self.account = None
self.node_settings = None
self.user_settings = None
self.user = AuthUserFactory()
self.auth = Auth(self.user)
self.node = ProjectFactory(creator=self.user)
if self.addon_type not in ("UNMANAGEABLE", "INVALID"):
if self.addon_type in ("OAUTH", "CONFIGURABLE"):
self.account = self.AccountFactory()
self.user.external_accounts.append(self.account)
self.user.save()
self.user_settings = self.user.get_or_add_addon(self.short_name)
self.node_settings = self.node.get_or_add_addon(self.short_name, auth=self.auth)
if self.addon_type in ("OAUTH", "CONFIGURABLE"):
self.node_settings.set_auth(self.account, self.user)
self._apply_auth_configuration()
if self.addon_type in ("OAUTH", "CONFIGURABLE"):
assert isinstance(self.node_settings, AddonOAuthNodeSettingsBase)
assert isinstance(self.user_settings, AddonOAuthUserSettingsBase)
self.account_id = self.account._id if self.account else None
self.set_urls()
def tearDown(self):
super(ApiAddonTestCase, self).tearDown()
self.user.remove()
self.node.remove()
if self.node_settings:
self.node_settings.remove()
if self.user_settings:
self.user_settings.remove()
if self.account:
self.account.remove()
class TestGoogleDriveNodeSettings(OsfTestCase):
def setUp(self):
super(TestGoogleDriveNodeSettings, self).setUp()
self.node = ProjectFactory()
self.node_settings = model.GoogleDriveNodeSettings(owner=self.node)
self.node_settings.save()
self.user = self.node.creator
self.user_settings = self.user.get_or_add_addon('googledrive')
def tearDown(self):
super(TestGoogleDriveNodeSettings, self).tearDown()
self.user_settings.remove()
self.node_settings.remove()
self.node.remove()
self.user.remove()
@mock.patch('website.addons.googledrive.model.GoogleDriveProvider')
def test_api_not_cached(self, mock_gdp):
# The first call to .api returns a new object
api = self.node_settings.api
mock_gdp.assert_called_once()
assert_equal(api, mock_gdp())
@mock.patch('website.addons.googledrive.model.GoogleDriveProvider')
def test_api_cached(self, mock_gdp):
# Repeated calls to .api returns the same object
self.node_settings._api = 'testapi'
api = self.node_settings.api
assert_false(mock_gdp.called)
assert_equal(api, 'testapi')
def test_set_auth(self):
external_account = GoogleDriveAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
# this should be reset after the call
self.node_settings.folder_id = 'anything'
self.node_settings.set_auth(
external_account=external_account,
user=self.user
)
# this instance is updated
assert_equal(
self.node_settings.external_account,
external_account
)
assert_equal(
self.node_settings.user_settings,
self.user_settings
)
assert_is_none(
self.node_settings.folder_id
)
set_auth_gives_access = self.user_settings.verify_oauth_access(
node=self.node,
external_account=external_account,
)
assert_true(set_auth_gives_access)
def test_set_auth_wrong_user(self):
external_account = GoogleDriveAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
with assert_raises(PermissionsError):
self.node_settings.set_auth(
external_account=external_account,
user=UserFactory()
)
def test_clear_auth(self):
self.node_settings.external_account = GoogleDriveAccountFactory()
self.node_settings.folder_id = 'something'
self.node_settings.user_settings = self.user_settings
self.node_settings.save()
self.node_settings.clear_auth()
assert_is_none(self.node_settings.external_account)
assert_is_none(self.node_settings.folder_id)
assert_is_none(self.node_settings.user_settings)
assert_is_none(self.node_settings.folder_path)
assert_is_none(self.node_settings.folder_name)
def test_set_target_folder(self):
folder = {
'id': 'fake-folder-id',
'name': 'fake-folder-name',
'path': 'fake_path'
}
external_account = GoogleDriveAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
self.node_settings.set_auth(
external_account=external_account,
user=self.user,
)
assert_is_none(self.node_settings.folder_id)
self.node_settings.set_target_folder(
folder,
auth=Auth(user=self.user),
)
# instance was updated
assert_equal(
self.node_settings.folder_id,
'fake-folder-id',
)
has_access = self.user_settings.verify_oauth_access(
node=self.node,
external_account=external_account,
metadata={'folder': 'fake-folder-id'}
)
# user_settings was updated
assert_true(has_access)
log = self.node.logs[-1]
assert_equal(log.action, 'googledrive_folder_selected')
assert_equal(log.params['folder'], folder['path'])
def test_has_auth_false(self):
external_account = GoogleDriveAccountFactory()
assert_false(self.node_settings.has_auth)
# both external_account and user_settings must be set to have auth
self.node_settings.external_account = external_account
assert_false(self.node_settings.has_auth)
self.node_settings.external_account = None
self.node_settings.user_settings = self.user_settings
assert_false(self.node_settings.has_auth)
# set_auth must be called to have auth
self.node_settings.external_account = external_account
self.node_settings.user_settings = self.user_settings
assert_false(self.node_settings.has_auth)
def test_has_auth_true(self):
external_account = GoogleDriveAccountFactory()
self.user.external_accounts.append(external_account)
self.node_settings.set_auth(external_account, self.user)
self.node_settings.folder_id = None
assert_true(self.node_settings.has_auth)
self.node_settings.folder_id = 'totally fake ID'
assert_true(self.node_settings.has_auth)
def test_selected_folder_name_root(self):
self.node_settings.folder_id = 'root'
assert_equal(
self.node_settings.selected_folder_name,
"Full Google Drive"
)
def test_selected_folder_name_empty(self):
self.node_settings.folder_id = None
assert_equal(
self.node_settings.selected_folder_name,
''
)
def test_selected_folder_name(self):
self.node_settings.folder_id = 'fake-id'
self.node_settings.folder_path = 'fake-folder-name'
self.node_settings.save()
assert_equal(
self.node_settings.selected_folder_name,
'fake-folder-name'
)
@mock.patch('website.addons.googledrive.model.GoogleDriveProvider.refresh_oauth_key')
def test_serialize_credentials(self, mock_refresh):
mock_refresh.return_value = True
external_account = GoogleDriveAccountFactory()
self.user.external_accounts.append(external_account)
self.node_settings.set_auth(external_account, self.user)
credentials = self.node_settings.serialize_waterbutler_credentials()
expected = {'token': self.node_settings.fetch_access_token()}
assert_equal(credentials, expected)
@mock.patch('website.addons.googledrive.model.GoogleDriveProvider.refresh_oauth_key')
def test_serialize_credentials_not_authorized(self, mock_refresh):
mock_refresh.return_value = True
external_account = GoogleDriveAccountFactory()
self.node_settings.external_account = external_account
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_credentials()
def test_serialize_settings(self):
self.node_settings.folder_id = 'fake-id'
self.node_settings.folder_path = 'fake-folder-name'
self.node_settings.save()
settings = self.node_settings.serialize_waterbutler_settings()
expected = {
'folder': {
'id': 'fake-id',
'name': 'fake-folder-name',
'path': 'fake-folder-name',
}
}
assert_equal(settings, expected)
def test_serialize_settings_not_configured(self):
self.node_settings.folder_id = None
self.node_settings.save()
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_settings()
def test_fetch_access_token_with_token_not_expired(self):
external_account = GoogleDriveAccountFactory()
self.user.external_accounts.append(external_account)
external_account.expires_at = datetime.utcnow() + relativedelta.relativedelta(minutes=6)
external_account.oauth_key = 'fake-token'
external_account.save()
self.node_settings.set_auth(external_account, self.user)
assert_equal(self.node_settings.fetch_access_token(), 'fake-token')
class TestBoxNodeSettingsModel(OsfTestCase):
def setUp(self):
super(TestBoxNodeSettingsModel, self).setUp()
self.node = ProjectFactory()
self.user = self.node.creator
self.external_account = BoxAccountFactory()
self.user.add_addon('box')
self.user.external_accounts.append(self.external_account)
self.user.save()
self.user_settings = self.user.get_addon('box')
self.user_settings.grant_oauth_access(
node=self.node,
external_account=self.external_account,
metadata={'folder': 'fake_folder_id'})
self.user_settings.save()
self.node_settings = BoxNodeSettingsFactory(
user_settings=self.user_settings,
folder_id='1234567890',
owner=self.node)
self.node_settings.external_account = self.external_account
self.node_settings.save()
def tearDown(self):
super(TestBoxNodeSettingsModel, self).tearDown()
self.user_settings.remove()
self.node_settings.remove()
self.external_account.remove()
self.node.remove()
self.user.remove()
def test_complete_true(self):
assert_true(self.node_settings.has_auth)
assert_true(self.node_settings.complete)
def test_complete_false(self):
self.user_settings.oauth_grants[self.node._id].pop(
self.external_account._id)
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_fields(self):
node_settings = BoxNodeSettings(user_settings=self.user_settings)
node_settings.save()
assert_true(node_settings.user_settings)
assert_equal(node_settings.user_settings.owner, self.user)
assert_true(hasattr(node_settings, 'folder_id'))
assert_true(hasattr(node_settings, 'user_settings'))
def test_folder_defaults_to_none(self):
node_settings = BoxNodeSettings(user_settings=self.user_settings)
node_settings.save()
assert_is_none(node_settings.folder_id)
def test_has_auth(self):
self.user.external_accounts = []
self.user_settings.reload()
settings = BoxNodeSettings(user_settings=self.user_settings)
settings.save()
assert_false(settings.has_auth)
self.user.external_accounts.append(self.external_account)
settings.reload()
assert_true(settings.has_auth)
def test_clear_auth(self):
node_settings = BoxNodeSettingsFactory()
node_settings.external_account = BoxAccountFactory()
node_settings.user_settings = BoxUserSettingsFactory()
node_settings.save()
node_settings.clear_auth()
assert_is_none(node_settings.external_account)
assert_is_none(node_settings.folder_id)
assert_is_none(node_settings.user_settings)
def test_to_json(self):
settings = self.node_settings
user = UserFactory()
result = settings.to_json(user)
assert_equal(result['addon_short_name'], 'box')
def test_delete(self):
assert_true(self.node_settings.user_settings)
assert_true(self.node_settings.folder_id)
old_logs = self.node.logs
self.node_settings.delete()
self.node_settings.save()
assert_is(self.node_settings.user_settings, None)
assert_is(self.node_settings.folder_id, None)
assert_true(self.node_settings.deleted)
assert_equal(self.node.logs, old_logs)
def test_deauthorize(self):
assert_true(self.node_settings.user_settings)
assert_true(self.node_settings.folder_id)
self.node_settings.deauthorize(auth=Auth(self.user))
self.node_settings.save()
assert_is(self.node_settings.user_settings, None)
assert_is(self.node_settings.folder_id, None)
last_log = self.node.logs[-1]
assert_equal(last_log.action, 'box_node_deauthorized')
params = last_log.params
assert_in('node', params)
assert_in('project', params)
assert_in('folder_id', params)
@mock.patch("website.addons.box.model.BoxNodeSettings._update_folder_data")
def test_set_folder(self, mock_update_folder):
folder_id = '1234567890'
self.node_settings.set_folder(folder_id, auth=Auth(self.user))
self.node_settings.save()
# Folder was set
assert_equal(self.node_settings.folder_id, folder_id)
# Log was saved
last_log = self.node.logs[-1]
assert_equal(last_log.action, 'box_folder_selected')
def test_set_user_auth(self):
node_settings = BoxNodeSettingsFactory()
user_settings = BoxUserSettingsFactory()
external_account = BoxAccountFactory()
user_settings.owner.external_accounts.append(external_account)
user_settings.save()
node_settings.external_account = external_account
node_settings.set_user_auth(user_settings)
node_settings.save()
assert_true(node_settings.has_auth)
assert_equal(node_settings.user_settings, user_settings)
# A log was saved
last_log = node_settings.owner.logs[-1]
assert_equal(last_log.action, 'box_node_authorized')
log_params = last_log.params
assert_equal(log_params['folder_id'], node_settings.folder_id)
assert_equal(log_params['node'], node_settings.owner._primary_key)
assert_equal(last_log.user, user_settings.owner)
@mock.patch("website.addons.box.model.refresh_oauth_key")
def test_serialize_credentials(self, mock_refresh):
mock_refresh.return_value = True
self.user_settings.access_token = 'key-11'
self.user_settings.save()
credentials = self.node_settings.serialize_waterbutler_credentials()
expected = {'token': self.node_settings.user_settings.access_token}
assert_equal(credentials, expected)
def test_serialize_credentials_not_authorized(self):
self.node_settings.user_settings = None
self.node_settings.save()
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_credentials()
def test_serialize_settings(self):
settings = self.node_settings.serialize_waterbutler_settings()
expected = {'folder': self.node_settings.folder_id}
assert_equal(settings, expected)
def test_serialize_settings_not_configured(self):
self.node_settings.folder_id = None
self.node_settings.save()
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_settings()
def test_create_log(self):
action = 'file_added'
path = 'pizza.nii'
nlog = len(self.node.logs)
self.node_settings.create_waterbutler_log(
auth=Auth(user=self.user),
action=action,
metadata={
'path': path,
'materialized': path
},
)
self.node.reload()
assert_equal(len(self.node.logs), nlog + 1)
assert_equal(
self.node.logs[-1].action,
'box_{0}'.format(action),
)
assert_equal(self.node.logs[-1].params['path'], path)
class MendeleyNodeSettingsTestCase(OsfTestCase):
def setUp(self):
super(MendeleyNodeSettingsTestCase, self).setUp()
self.node = ProjectFactory()
self.node_settings = model.MendeleyNodeSettings(owner=self.node)
self.node_settings.save()
self.user = self.node.creator
self.user_settings = self.user.get_or_add_addon('mendeley')
def tearDown(self):
super(MendeleyNodeSettingsTestCase, self).tearDown()
self.user_settings.remove()
self.node_settings.remove()
self.node.remove()
self.user.remove()
@mock.patch('website.addons.mendeley.model.Mendeley')
def test_api_not_cached(self, mock_mendeley):
# The first call to .api returns a new object
api = self.node_settings.api
mock_mendeley.assert_called_once()
assert_equal(api, mock_mendeley())
@mock.patch('website.addons.mendeley.model.Mendeley')
def test_api_cached(self, mock_mendeley):
# Repeated calls to .api returns the same object
self.node_settings._api = 'testapi'
api = self.node_settings.api
assert_false(mock_mendeley.called)
assert_equal(api, 'testapi')
def test_set_auth(self):
external_account = MendeleyAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
# this should be reset after the call
self.node_settings.mendeley_list_id = 'anything'
self.node_settings.set_auth(external_account=external_account,
user=self.user)
# this instance is updated
assert_equal(self.node_settings.external_account, external_account)
assert_equal(self.node_settings.user_settings, self.user_settings)
assert_is_none(self.node_settings.mendeley_list_id)
# user_settings was updated
# TODO: The call to grant_oauth_access in set_auth should be mocked
assert_true(
self.user_settings.verify_oauth_access(
node=self.node,
external_account=external_account,
))
def test_set_auth_wrong_user(self):
external_account = MendeleyAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
with assert_raises(PermissionsError):
self.node_settings.set_auth(external_account=external_account,
user=UserFactory())
def test_deauthorize(self):
self.node_settings.external_account = MendeleyAccountFactory()
self.node_settings.mendeley_list_id = 'something'
self.node_settings.user_settings = self.user_settings
self.node_settings.save()
assert_true(self.node_settings.mendeley_list_id)
self.node_settings.deauthorize(auth=Auth(self.user))
self.node_settings.save()
assert_is(self.node_settings.user_settings, None)
assert_is(self.node_settings.mendeley_list_id, None)
last_log = self.node.logs[-1]
assert_equal(last_log.action, 'mendeley_node_deauthorized')
params = last_log.params
assert_in('node', params)
assert_in('project', params)
def test_clear_auth(self):
self.node_settings.external_account = MendeleyAccountFactory()
self.node_settings.mendeley_list_id = 'something'
self.node_settings.user_settings = self.user_settings
self.node_settings.save()
self.node_settings.clear_auth()
assert_is_none(self.node_settings.external_account)
assert_is_none(self.node_settings.mendeley_list_id)
assert_is_none(self.node_settings.user_settings)
def test_set_target_folder(self):
folder_id = 'fake-folder-id'
folder_name = 'fake-folder-name'
external_account = MendeleyAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
self.node_settings.set_auth(
external_account=external_account,
user=self.user,
)
assert_is_none(self.node_settings.mendeley_list_id)
self.node_settings.set_target_folder(
folder_id,
folder_name,
auth=Auth(user=self.user),
)
# instance was updated
assert_equal(
self.node_settings.mendeley_list_id,
'fake-folder-id',
)
# user_settings was updated
# TODO: the call to grant_oauth_access should be mocked
assert_true(
self.user_settings.verify_oauth_access(
node=self.node,
external_account=external_account,
metadata={'folder': 'fake-folder-id'}))
log = self.node.logs[-1]
assert_equal(log.action, 'mendeley_folder_selected')
assert_equal(log.params['folder_id'], folder_id)
assert_equal(log.params['folder_name'], folder_name)
def test_has_auth_false(self):
external_account = MendeleyAccountFactory()
assert_false(self.node_settings.has_auth)
# both external_account and user_settings must be set to have auth
self.node_settings.external_account = external_account
assert_false(self.node_settings.has_auth)
self.node_settings.external_account = None
self.node_settings.user_settings = self.user_settings
assert_false(self.node_settings.has_auth)
# set_auth must be called to have auth
self.node_settings.external_account = external_account
self.node_settings.user_settings = self.user_settings
assert_false(self.node_settings.has_auth)
def test_has_auth_true(self):
external_account = MendeleyAccountFactory()
self.user.external_accounts.append(external_account)
self.node_settings.set_auth(external_account, self.user)
# mendeley_list_id should have no effect
self.node_settings.mendeley_list_id = None
assert_true(self.node_settings.has_auth)
# mendeley_list_id should have no effect
self.node_settings.mendeley_list_id = 'totally fake ID'
assert_true(self.node_settings.has_auth)
def test_selected_folder_name_root(self):
self.node_settings.mendeley_list_id = 'ROOT'
assert_equal(self.node_settings.selected_folder_name, "All Documents")
def test_selected_folder_name_empty(self):
self.node_settings.mendeley_list_id = None
assert_equal(self.node_settings.selected_folder_name, '')
@mock.patch('website.addons.mendeley.model.Mendeley._folder_metadata')
def test_selected_folder_name(self, mock_folder_metadata):
# Mock the return from api call to get the folder's name
mock_folder = mock.Mock()
mock_folder.name = 'Fake Folder'
# Add the mocked return object to the mocked api client
mock_folder_metadata.return_value = mock_folder
self.node_settings.mendeley_list_id = 'fake-list-id'
assert_equal(self.node_settings.selected_folder_name, 'Fake Folder')
# TODO: Make these tests generic and move to core
@mock.patch('framework.status.push_status_message')
def test_remove_contributor_authorizer(self, mock_push_status):
external_account = MendeleyAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
self.node_settings.set_auth(external_account, self.user)
contributor = UserFactory()
self.node.add_contributor(contributor,
permissions=['read', 'write', 'admin'])
self.node.remove_contributor(self.node.creator,
auth=Auth(user=contributor))
assert_false(self.node_settings.has_auth)
assert_false(
self.user_settings.verify_oauth_access(self.node,
external_account))
def test_remove_contributor_not_authorizer(self):
external_account = MendeleyAccountFactory()
self.user.external_accounts.append(external_account)
self.node_settings.set_auth(external_account, self.user)
contributor = UserFactory()
self.node.add_contributor(contributor)
self.node.remove_contributor(contributor,
auth=Auth(user=self.node.creator))
assert_true(self.node_settings.has_auth)
assert_true(
self.user_settings.verify_oauth_access(self.node,
external_account))
@mock.patch('framework.status.push_status_message')
def test_fork_by_authorizer(self, mock_push_status):
external_account = MendeleyAccountFactory()
self.user.external_accounts.append(external_account)
self.node_settings.set_auth(external_account, self.user)
fork = self.node.fork_node(auth=Auth(user=self.node.creator))
assert_true(fork.get_addon('mendeley').has_auth)
assert_true(
self.user_settings.verify_oauth_access(fork, external_account))
@mock.patch('framework.status.push_status_message')
def test_fork_not_by_authorizer(self, mock_push_status):
external_account = MendeleyAccountFactory()
self.user.external_accounts.append(external_account)
self.node_settings.set_auth(external_account, self.user)
contributor = UserFactory()
self.node.add_contributor(contributor)
fork = self.node.fork_node(auth=Auth(user=contributor))
assert_false(fork.get_addon('mendeley').has_auth)
assert_false(
self.user_settings.verify_oauth_access(fork, external_account))
class ApiAddonTestCase(ApiTestCase):
"""Base `TestCase` for tests that require interaction with addons.
"""
@abc.abstractproperty
def short_name(self):
pass
@abc.abstractproperty
def addon_type(self):
pass
@abc.abstractmethod
def _apply_auth_configuration(self):
pass
@abc.abstractmethod
def _set_urls(self):
pass
def _settings_kwargs(self, node, user_settings):
return {
'user_settings': self.user_settings,
'folder_id': '1234567890',
'owner': self.node
}
def setUp(self):
super(ApiAddonTestCase, self).setUp()
from tests.factories import (
ProjectFactory,
AuthUserFactory,
)
from website.addons.base import (AddonOAuthNodeSettingsBase,
AddonNodeSettingsBase,
AddonOAuthUserSettingsBase,
AddonUserSettingsBase)
assert self.addon_type in ('CONFIGURABLE', 'OAUTH', 'UNMANAGEABLE',
'INVALID')
self.account = None
self.node_settings = None
self.user_settings = None
self.user = AuthUserFactory()
self.auth = Auth(self.user)
self.node = ProjectFactory(creator=self.user)
if self.addon_type not in ('UNMANAGEABLE', 'INVALID'):
if self.addon_type in ('OAUTH', 'CONFIGURABLE'):
self.account = self.AccountFactory()
self.user.external_accounts.append(self.account)
self.user.save()
self.user_settings = self.user.get_or_add_addon(self.short_name)
self.node_settings = self.node.get_or_add_addon(self.short_name,
auth=self.auth)
if self.addon_type in ('OAUTH', 'CONFIGURABLE'):
self.node_settings.set_auth(self.account, self.user)
self._apply_auth_configuration()
if self.addon_type in ('OAUTH', 'CONFIGURABLE'):
assert isinstance(self.node_settings, AddonOAuthNodeSettingsBase)
assert isinstance(self.user_settings, AddonOAuthUserSettingsBase)
self.account_id = self.account._id if self.account else None
self.set_urls()
def tearDown(self):
super(ApiAddonTestCase, self).tearDown()
self.user.remove()
self.node.remove()
if self.node_settings:
self.node_settings.remove()
if self.user_settings:
self.user_settings.remove()
if self.account:
self.account.remove()
class TestGoogleDriveNodeSettings(OsfTestCase):
def setUp(self):
super(TestGoogleDriveNodeSettings, self).setUp()
self.node = ProjectFactory()
self.node_settings = model.GoogleDriveNodeSettings(owner=self.node)
self.node_settings.save()
self.user = self.node.creator
self.user_settings = self.user.get_or_add_addon("googledrive")
def tearDown(self):
super(TestGoogleDriveNodeSettings, self).tearDown()
self.user_settings.remove()
self.node_settings.remove()
self.node.remove()
self.user.remove()
@mock.patch("website.addons.googledrive.model.GoogleDriveProvider")
def test_api_not_cached(self, mock_gdp):
# The first call to .api returns a new object
api = self.node_settings.api
mock_gdp.assert_called_once()
assert_equal(api, mock_gdp())
@mock.patch("website.addons.googledrive.model.GoogleDriveProvider")
def test_api_cached(self, mock_gdp):
# Repeated calls to .api returns the same object
self.node_settings._api = "testapi"
api = self.node_settings.api
assert_false(mock_gdp.called)
assert_equal(api, "testapi")
def test_set_auth(self):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
# this should be reset after the call
self.node_settings.folder_id = "anything"
self.node_settings.set_auth(external_account=external_account, user=self.user)
# this instance is updated
assert_equal(self.node_settings.external_account, external_account)
assert_equal(self.node_settings.user_settings, self.user_settings)
assert_is_none(self.node_settings.folder_id)
set_auth_gives_access = self.user_settings.verify_oauth_access(
node=self.node, external_account=external_account
)
assert_true(set_auth_gives_access)
def test_set_auth_wrong_user(self):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
with assert_raises(PermissionsError):
self.node_settings.set_auth(external_account=external_account, user=UserFactory())
def test_clear_auth(self):
self.node_settings.external_account = ExternalAccountFactory()
self.node_settings.folder_id = "something"
self.node_settings.user_settings = self.user_settings
self.node_settings.save()
self.node_settings.clear_auth()
assert_is_none(self.node_settings.external_account)
assert_is_none(self.node_settings.folder_id)
assert_is_none(self.node_settings.user_settings)
assert_is_none(self.node_settings.folder_path)
assert_is_none(self.node_settings.folder_name)
def test_set_target_folder(self):
folder = {"id": "fake-folder-id", "name": "fake-folder-name", "path": "fake_path"}
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.user.save()
self.node_settings.set_auth(external_account=external_account, user=self.user)
assert_is_none(self.node_settings.folder_id)
self.node_settings.set_target_folder(folder, auth=Auth(user=self.user))
# instance was updated
assert_equal(self.node_settings.folder_id, "fake-folder-id")
has_access = self.user_settings.verify_oauth_access(
node=self.node, external_account=external_account, metadata={"folder": "fake-folder-id"}
)
# user_settings was updated
assert_true(has_access)
log = self.node.logs[-1]
assert_equal(log.action, "googledrive_folder_selected")
assert_equal(log.params["folder"], folder["path"])
def test_has_auth_false(self):
external_account = ExternalAccountFactory()
assert_false(self.node_settings.has_auth)
# both external_account and user_settings must be set to have auth
self.node_settings.external_account = external_account
assert_false(self.node_settings.has_auth)
self.node_settings.external_account = None
self.node_settings.user_settings = self.user_settings
assert_false(self.node_settings.has_auth)
# set_auth must be called to have auth
self.node_settings.external_account = external_account
self.node_settings.user_settings = self.user_settings
assert_false(self.node_settings.has_auth)
def test_has_auth_true(self):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.node_settings.set_auth(external_account, self.user)
self.node_settings.folder_id = None
assert_true(self.node_settings.has_auth)
self.node_settings.folder_id = "totally fake ID"
assert_true(self.node_settings.has_auth)
def test_selected_folder_name_root(self):
self.node_settings.folder_id = "root"
assert_equal(self.node_settings.selected_folder_name, "Full Google Drive")
def test_selected_folder_name_empty(self):
self.node_settings.folder_id = None
assert_equal(self.node_settings.selected_folder_name, "")
def test_selected_folder_name(self):
self.node_settings.folder_id = "fake-id"
self.node_settings.folder_path = "fake-folder-name"
self.node_settings.save()
assert_equal(self.node_settings.selected_folder_name, "fake-folder-name")
def test_serialize_credentials(self):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
self.node_settings.set_auth(external_account, self.user)
credentials = self.node_settings.serialize_waterbutler_credentials()
expected = {"token": self.node_settings.fetch_access_token()}
assert_equal(credentials, expected)
def test_serialize_credentials_not_authorized(self):
external_account = ExternalAccountFactory()
self.node_settings.external_account = external_account
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_credentials()
def test_serialize_settings(self):
self.node_settings.folder_id = "fake-id"
self.node_settings.folder_path = "fake-folder-name"
self.node_settings.save()
settings = self.node_settings.serialize_waterbutler_settings()
expected = {"folder": {"id": "fake-id", "name": "fake-folder-name", "path": "fake-folder-name"}}
assert_equal(settings, expected)
def test_serialize_settings_not_configured(self):
self.node_settings.folder_id = None
self.node_settings.save()
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_settings()
def test_fetch_access_token_with_token_not_expired(self):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
external_account.expires_at = datetime.utcnow() + relativedelta.relativedelta(minutes=6)
external_account.oauth_key = "fake-token"
external_account.save()
self.node_settings.set_auth(external_account, self.user)
assert_equal(self.node_settings.fetch_access_token(), "fake-token")
@mock.patch.object(GoogleAuthClient, "refresh")
def test_fetch_access_token_with_token_expired(self, mock_refresh):
external_account = ExternalAccountFactory()
self.user.external_accounts.append(external_account)
external_account.expires_at = datetime.utcnow() + relativedelta.relativedelta(minutes=4)
external_account.oauth_key = "fake-token"
external_account.refresh_token = "refresh-fake-token"
external_account.save()
fake_token = {"access_token": "new-access-token", "refresh_token": "new-refresh-token", "expires_at": 1234.5}
mock_refresh.return_value = fake_token
self.node_settings.set_auth(external_account, self.user)
self.node_settings.fetch_access_token()
mock_refresh.assert_called_once()
assert_equal(external_account.oauth_key, "new-access-token")
assert_equal(external_account.refresh_token, "new-refresh-token")
assert_equal(external_account.expires_at, datetime.utcfromtimestamp(1234.5))