def test_merge_accounts(self):
self.assertEqual(0, merge_accounts(self.db, {}, []))
master_id = self.db.users.insert({
'email': '*****@*****.**',
'twitter_id': 1234,
'authorized_apps': ['a', 'b'],
}, safe=True)
master_user = self.db.users.find_one({'_id': master_id}, safe=True)
self.db.passwords.insert({
'owner': master_id,
'password1': 'secret1',
}, safe=True)
# merging with itself does nothing
self.assertEqual(1, self.db.users.count())
self.assertEqual(0, merge_accounts(self.db, master_user,
[str(master_id)]))
master_user_reloaded = self.db.users.find_one({'_id': master_id},
safe=True)
self.assertEqual(master_user, master_user_reloaded)
self.assertEqual(1, self.db.users.count())
# merge with invented users does nothing neither
self.assertEqual(0, merge_accounts(self.db, master_user,
['000000000000000000000000']))
master_user_reloaded = self.db.users.find_one({'_id': master_id},
safe=True)
self.assertEqual(master_user, master_user_reloaded)
self.assertEqual(1, self.db.users.count())
# let's create valid users
other_id = self.db.users.insert({
'email': '*****@*****.**',
'google_id': 4321,
'authorized_apps': ['b', 'c'],
}, safe=True)
self.assertEqual(2, self.db.users.count())
self.db.passwords.insert({
'owner': other_id,
'password2': 'secret2',
}, safe=True)
self.assertEqual(1, merge_accounts(self.db, master_user,
[str(other_id)]))
master_user_reloaded = self.db.users.find_one({'_id': master_id},
safe=True)
self.assertEqual({
'_id': master_id,
'email': '*****@*****.**',
'twitter_id': 1234,
'google_id': 4321,
'authorized_apps': ['a', 'b', 'c'],
}, master_user_reloaded)
self.assertEqual(1, self.db.users.count())
self.assertEqual(2,
self.db.passwords.find({'owner': master_id}).count())
def test_merge_valid_users(self):
master_id, master_user = self._create_master_user()
# let's create valid users
other_id = self.db.users.insert({
'email': '*****@*****.**',
'google_id': 4321,
})
self._add_authorized_app(other_id, 'b')
self._add_authorized_app(other_id, 'c')
self.assertEqual(2, self.db.users.count())
self.db.passwords.insert({
'owner': other_id,
'password2': 'secret2',
})
self.assertEqual(1, merge_accounts(self.db, master_user,
[str(other_id)]))
master_user_reloaded = self.db.users.find_one({'_id': master_id})
self.assertEqual({
'_id': master_id,
'email': '*****@*****.**',
'twitter_id': 1234,
'google_id': 4321,
}, master_user_reloaded)
self.assertEqual(1, self.db.users.count())
self.assertEqual(2,
self.db.passwords.find({'owner': master_id}).count())
def test_merge_with_invented_users(self):
master_id, master_user = self._create_master_user()
self.assertEqual(0, merge_accounts(self.db, master_user,
['000000000000000000000000']))
master_user_reloaded = self.db.users.find_one({'_id': master_id})
self.assertEqual(master_user, master_user_reloaded)
self.assertEqual(1, self.db.users.count())
def test_merge_with_itself(self):
user = User()
Session.add(user)
Session.flush()
self.assertEqual(1, Session.query(User).count())
self.assertEqual(0, merge_accounts(user, [user.id]))
self.assertEqual(1, Session.query(User).count())
def test_merge_with_invented_users(self):
user = User()
Session.add(user)
Session.flush()
fake_id = '00000000-0000-0000-0000-000000000000'
self.assertEqual(1, Session.query(User).count())
self.assertEqual(0, merge_accounts(user, [fake_id]))
self.assertEqual(1, Session.query(User).count())
def test_merge_valid_users(self):
master_user = User()
Session.add(master_user)
other_user = User()
Session.add(other_user)
Session.flush()
self.assertEqual(2, Session.query(User).count())
self.assertEqual(1, merge_accounts(master_user, [other_user.id]))
self.assertEqual(1, Session.query(User).count())
def identity_providers(request):
current_provider = request.session.get('current_provider', None)
accounts = get_accounts(request.db, request.user, current_provider)
context = {
'accounts': accounts
}
verified = [ac for ac in accounts if ac['is_verified']]
context['can_merge'] = len(verified) > 1
if 'submit' in request.POST:
if not context['can_merge']:
return HTTPBadRequest('You do not have enough accounts to merge')
def is_verified(ac):
for a in accounts:
if a['id'] == ac:
return a['is_verified']
return False
accounts_to_merge = [account.replace('account-', '')
for account in request.POST.keys()
if account != 'submit']
accounts_to_merge = [account
for account in accounts_to_merge
if is_verified(account)]
if len(accounts_to_merge) > 1:
merged = merge_accounts(request.db, request.user,
accounts_to_merge)
localizer = get_localizer(request)
msg = localizer.pluralize(
_('Congratulations, ${n_merged} of your accounts has been merged into the current one'),
_('Congratulations, ${n_merged} of your accounts have been merged into the current one'),
merged,
domain=translation_domain,
mapping={'n_merged': merged},
)
request.session.flash(msg, 'success')
else:
request.session.flash(
_('Not enough accounts for merging'),
'error',
)
return HTTPFound(
location=request.route_path('user_identity_providers'))
return context
def identity_providers(request):
current_provider = request.session.get('current_provider', None)
accounts = request.user.get_accounts(current_provider)
context = {'accounts': accounts}
verified = [ac for ac in accounts if ac['is_verified']]
context['can_merge'] = len(verified) > 1
if 'submit' in request.POST:
if not context['can_merge']:
return HTTPBadRequest('You do not have enough accounts to merge')
def is_verified(ac):
for a in accounts:
if a['id'] == ac:
return a['is_verified']
return False
accounts_to_merge = [
account.replace('account-', '') for account in request.POST.keys()
if account != 'submit'
]
accounts_to_merge = [
account for account in accounts_to_merge if is_verified(account)
]
if len(accounts_to_merge) > 1:
merged = merge_accounts(request.user, accounts_to_merge)
localizer = get_localizer(request)
msg = localizer.pluralize(
_('Congratulations, ${n_merged} of your accounts has been merged into the current one'
),
_('Congratulations, ${n_merged} of your accounts have been merged into the current one'
),
merged,
domain=translation_domain,
mapping={'n_merged': merged},
)
request.session.flash(msg, 'success')
else:
request.session.flash(
_('Not enough accounts for merging'),
'error',
)
return HTTPFound(
location=request.route_path('user_identity_providers'))
return context
def test_merge_empty_user(self):
self.assertEqual(0, merge_accounts(self.db, {}, []))
def test_merge_empty_user(self):
self.assertEqual(0, merge_accounts(None, []))
