def test_get_targets(self):
now = datetime.datetime.utcnow()
records = [
BoxAccountFactory(expires_at=now + datetime.timedelta(days=4)),
BoxAccountFactory(expires_at=now + datetime.timedelta(days=2)),
GoogleDriveAccountFactory(expires_at=now +
datetime.timedelta(days=4)),
GoogleDriveAccountFactory(expires_at=now +
datetime.timedelta(days=2)),
MendeleyAccountFactory(expires_at=now +
datetime.timedelta(days=4)),
MendeleyAccountFactory(expires_at=now +
datetime.timedelta(days=2)),
]
box_targets = list(
get_targets(delta=relativedelta(days=-3), addon_short_name='box'))
drive_targets = list(
get_targets(delta=relativedelta(days=-3),
addon_short_name='googledrive'))
mendeley_targets = list(
get_targets(delta=relativedelta(days=-3),
addon_short_name='mendeley'))
assert_equal(records[1]._id, box_targets[0]._id)
assert_not_in(records[0], box_targets)
assert_equal(records[3]._id, drive_targets[0]._id)
assert_not_in(records[2], drive_targets)
assert_equal(records[5]._id, mendeley_targets[0]._id)
assert_not_in(records[4], mendeley_targets)
def test_refresh(self, mock_box_refresh, mock_drive_refresh,
mock_mendeley_refresh):
fake_authorized_box_account = BoxAccountFactory(
date_last_refreshed=datetime.datetime.utcnow())
fake_authorized_drive_account = GoogleDriveAccountFactory(
date_last_refreshed=datetime.datetime.utcnow())
fake_authorized_mendeley_account = MendeleyAccountFactory(
date_last_refreshed=datetime.datetime.utcnow())
fake_unauthorized_box_account = BoxAccountFactory(
date_last_refreshed=datetime.datetime.utcnow() -
datetime.timedelta(days=4))
fake_unauthorized_drive_account = GoogleDriveAccountFactory(
date_last_refreshed=datetime.datetime.utcnow() -
datetime.timedelta(days=4))
fake_unauthorized_mendeley_account = MendeleyAccountFactory(
date_last_refreshed=datetime.datetime.utcnow() -
datetime.timedelta(days=4))
for addon in self.addons:
Provider = look_up_provider(addon)
main(delta=relativedelta(days=3),
Provider=Provider,
rate_limit=(5, 1),
dry_run=False)
assert_equal(1, mock_box_refresh.call_count)
assert_equal(1, mock_drive_refresh.call_count)
assert_equal(1, mock_mendeley_refresh.call_count)
def test_one_user_with_multiple_addons(self):
results = AddonSnapshot().get_events()
github_res = [
res for res in results if res['provider']['name'] == 'github'
][0]
googledrive_res = [
res for res in results if res['provider']['name'] == 'googledrive'
][0]
assert_equal(github_res['users']['total'], 1)
assert_equal(googledrive_res['users']['total'], 0)
self.user.add_addon('googledrive')
oauth_settings = GoogleDriveAccountFactory()
oauth_settings.save()
self.user.external_accounts.append(oauth_settings)
self.user.save()
results = AddonSnapshot().get_events()
github_res = [
res for res in results if res['provider']['name'] == 'github'
][0]
googledrive_res = [
res for res in results if res['provider']['name'] == 'googledrive'
][0]
assert_equal(github_res['users']['total'], 1)
assert_equal(googledrive_res['users']['total'], 1)
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')
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 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)')
def test_serialize_credentials(self):
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)
def test_one_user_with_multiple_addons(self):
results = AddonSnapshot().get_events()
github_res = [res for res in results if res['provider']['name'] == 'github'][0]
googledrive_res = [res for res in results if res['provider']['name'] == 'googledrive'][0]
assert_equal(github_res['users']['total'], 1)
assert_equal(googledrive_res['users']['total'], 0)
self.user.add_addon('googledrive')
oauth_settings = GoogleDriveAccountFactory()
oauth_settings.save()
self.user.external_accounts.append(oauth_settings)
self.user.save()
results = AddonSnapshot().get_events()
github_res = [res for res in results if res['provider']['name'] == 'github'][0]
googledrive_res = [res for res in results if res['provider']['name'] == 'googledrive'][0]
assert_equal(github_res['users']['total'], 1)
assert_equal(googledrive_res['users']['total'], 1)
def test_one_user_with_multiple_addons(self):
results = AddonSnapshot().get_events()
github_res = [res for res in results if res["provider"]["name"] == "github"][0]
googledrive_res = [res for res in results if res["provider"]["name"] == "googledrive"][0]
assert_equal(github_res["users"]["enabled"], 1)
assert_equal(googledrive_res["users"]["enabled"], 0)
self.user.add_addon("googledrive")
oauth_settings = GoogleDriveAccountFactory()
oauth_settings.save()
self.user.external_accounts.append(oauth_settings)
self.user.save()
results = AddonSnapshot().get_events()
github_res = [res for res in results if res["provider"]["name"] == "github"][0]
googledrive_res = [res for res in results if res["provider"]["name"] == "googledrive"][0]
assert_equal(github_res["users"]["enabled"], 1)
assert_equal(googledrive_res["users"]["enabled"], 1)
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_list_googledrive_accounts_returns_accounts_multiple(self):
external_account = GoogleDriveAccountFactory()
self.user.external_accounts.append(
external_account) # self.account is already present
self.user.save()
url = api_url_for('list_googledrive_user_accounts')
res = self.app.get(url)
assert_equal(res.status_code, 200)
assert_equal(len(res.json['accounts']), 2)
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 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_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 setUp(self):
super(TestGoogleDriveConfigViews, self).setUp()
self.account = GoogleDriveAccountFactory()
self.user = AuthUserFactory(external_accounts=[self.account])
self.user_settings = self.user.get_or_add_addon('googledrive')
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('googledrive', Auth(self.user))
self.node_settings = self.project.get_addon('googledrive')
self.node_settings.user_settings = self.user_settings
self.node_settings.save()
self.user_settings.save()
# Log user in
self.app.authenticate(*self.user.auth)
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')
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_one_node_with_multiple_addons(self):
results = AddonSnapshot().get_events()
github_res = [res for res in results if res["provider"]["name"] == "github"][0]
googledrive_res = [res for res in results if res["provider"]["name"] == "googledrive"][0]
assert_equal(github_res["nodes"]["total"], 1)
assert_equal(googledrive_res["nodes"]["total"], 0)
self.user.add_addon("googledrive")
user_addon = self.user.get_addon("googledrive")
oauth_settings = GoogleDriveAccountFactory()
oauth_settings.save()
self.user.external_accounts.append(oauth_settings)
self.user.save()
self.node.add_addon("googledrive", Auth(self.user))
node_addon = self.node.get_addon("googledrive")
node_addon.user = self.user.fullname
node_addon.user_settings = user_addon
node_addon.external_account = oauth_settings
node_addon.save()
results = AddonSnapshot().get_events()
github_res = [res for res in results if res["provider"]["name"] == "github"][0]
googledrive_res = [res for res in results if res["provider"]["name"] == "googledrive"][0]
assert_equal(github_res["nodes"]["total"], 1)
assert_equal(googledrive_res["nodes"]["total"], 1)
def test_refresh(self, mock_box_refresh, mock_drive_refresh,
mock_mendeley_refresh):
fake_box_account = BoxAccountFactory(
expires_at=datetime.datetime.utcnow())
fake_drive_account = GoogleDriveAccountFactory(
expires_at=datetime.datetime.utcnow())
fake_mendeley_account = MendeleyAccountFactory(
expires_at=datetime.datetime.utcnow())
for addon in self.addons:
Provider = look_up_provider(addon)
main(delta=relativedelta(days=-3),
Provider=Provider,
dry_run=False)
assert_equal(1, mock_box_refresh.call_count)
assert_equal(1, mock_drive_refresh.call_count)
assert_equal(1, mock_mendeley_refresh.call_count)
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_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_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_fetch_access_token_with_token_expired(self, mock_refresh):
external_account = GoogleDriveAccountFactory()
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))
def test_fetch_access_token_with_token_expired(self, mock_refresh):
external_account = GoogleDriveAccountFactory()
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))
def test_serialize_credentials_not_authorized(self):
external_account = GoogleDriveAccountFactory()
self.node_settings.external_account = external_account
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_credentials()
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 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)
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()