def test_sus_exist(self, mock_find_u_with_role):
"""
Test that super users are returned if they exist.
"""
user_man = managers.UserManager()
super_users = user_man.get_admins()
self.assertTrue(super_users, mock_find_u_with_role.return_value)
def test_dupe(self, mock_col):
"""
Test the attemtped creation of a duplicate user.
"""
mock_col.return_value.find_one.return_value = 'exists already'
user_man = managers.UserManager()
self.assertRaises(exceptions.DuplicateResource, user_man.create_user,
'test')
def test_missing_role(self, mock_col):
"""
Ensure that if the role does not exist, MissingResource is raised.
"""
mock_col.return_value.find_one.return_value = None
user_man = managers.UserManager()
self.assertRaises(exceptions.MissingResource,
user_man.find_users_belonging_to_role, 'role')
def test_handle_missing_role(self, mock_find_u_with_role):
"""
Test that if the role reqested does not exist, super_users is None.
"""
user_man = managers.UserManager()
mock_find_u_with_role.side_effect = exceptions.MissingResource()
super_users = user_man.get_admins()
self.assertTrue(super_users is None)
def test_already_admin(self, mock_f, mock_conf, mock_get_admins, mock_col):
"""
Test that if admins already exist, another is not created.
"""
mock_get_admins.return_value = 'some admins'
user_man = managers.UserManager()
user_man.ensure_admin()
self.assertFalse(mock_col.called)
def _auto_manage_db(options):
"""
Find and apply all available database migrations, and install or update all available content
types.
:param options: The command line parameters from the user.
"""
unperformed_migrations = False
message = _('Loading content types.')
_logger.info(message)
# Note that if dry_run is False, None is always returned
old_content_types = load_content_types(dry_run=options.dry_run)
if old_content_types:
for content_type in old_content_types:
message = _(
'Would have created or updated the following type definition: '
+ content_type.id)
_logger.info(message)
message = _('Content types loaded.')
_logger.info(message)
message = _('Ensuring the admin role and user are in place.')
_logger.info(message)
# Due to the silliness of the factory, we have to initialize it because the UserManager and
# RoleManager are going to try to use it.
factory.initialize()
role_manager = RoleManager()
if options.dry_run:
if not role_manager.get_role(SUPER_USER_ROLE):
unperformed_migrations = True
message = _('Would have created the admin role.')
_logger.info(message)
else:
role_manager.ensure_super_user_role()
user_manager = managers.UserManager()
if options.dry_run:
if not user_manager.get_admins():
unperformed_migrations = True
message = _('Would have created the default admin user.')
_logger.info(message)
else:
user_manager.ensure_admin()
message = _('Admin role and user are in place.')
_logger.info(message)
message = _('Beginning database migrations.')
_logger.info(message)
migrate_database(options)
message = _('Database migrations complete.')
_logger.info(message)
if unperformed_migrations:
return 1
return os.EX_OK
def test_invalid_values(self, mock_inv_type, mock_col):
"""
Test that all invalid values are caught and raised.
"""
mock_col.return_value.find_one.return_value = None
mock_inv_type.return_value = True
user_man = managers.UserManager()
try:
user_man.create_user(None)
except exceptions.InvalidValue, e:
pass
def test_as_expected(self, mock_find_all, mock_col):
"""
Ensure that all users with the requested role are returned.
"""
user_1 = {'roles': ['r1', 'r2']}
user_2 = {'roles': ['r2', 'r3']}
user_3 = {'roles': ['r3', 'r4']}
mock_find_all.return_value = [user_1, user_2, user_3]
user_man = managers.UserManager()
users = user_man.find_users_belonging_to_role('r2')
self.assertEqual(sorted([user_1, user_2]), sorted(users))
def test_as_expected(self, mock_col):
"""
Test the expected path of find_all.
"""
user_1 = {'login': '******', 'password': '******'}
user_2 = {'login': '******', 'password': '******'}
mock_col.return_value.find.return_value = [user_1, user_2]
user_man = managers.UserManager()
all_users = user_man.find_all()
self.assertEqual(len(all_users), 2)
# Password should not be in the dict.
self.assertDictEqual(all_users[0], {'login': '******'})
self.assertDictEqual(all_users[1], {'login': '******'})
def test_admin_without_role(self, mock_create, mock_f, mock_conf,
mock_get_admins, mock_col):
"""
Test that if the default admin user does exist, but does not have admin, it is given admin.
"""
mock_get_admins.return_value = False
mock_conf.config.get.return_value = 'default'
mock_col.return_value.find_one.return_value = 'admin'
user_man = managers.UserManager()
user_man.ensure_admin()
self.assertFalse(mock_create.called)
mock_f.role_manager.return_value.add_user_to_role.assert_called_once_with(
'super-users', 'default')
def test_no_admins(self, mock_create, mock_f, mock_conf, mock_get_admins,
mock_col):
"""
Test that if admins do not exist, one is created using the default values.
"""
mock_get_admins.return_value = False
mock_conf.config.get.return_value = 'default'
mock_col.return_value.find_one.return_value = None
user_man = managers.UserManager()
user_man.ensure_admin()
mock_create.assert_called_once_with(login='******',
password='******')
mock_f.role_manager.return_value.add_user_to_role.assert_called_once_with(
'super-users', 'default')
def test_as_expected(self, mock_inv_type, mock_user_model, mock_f,
mock_col):
"""
Test that user creation works as expected.
"""
def find_user(*args):
"""Dirty trick to return None the first time, and a user the second time."""
return args[0].pop()
perm_man = mock_f.permission_manager.return_value
created = {'created': 'user', 'password': '******'}
mock_col.return_value.find_one.side_effect = functools.partial(
find_user, [created, None])
mock_inv_type.return_value = False
mock_user = mock_user_model.return_value
mock_user.login = '******'
user_man = managers.UserManager()
user = user_man.create_user('mlogin', 'mpass', roles=['mock', 'roles'])
mock_user.set_password.assert_called_once_with('mpass')
mock_user.save.assert_called_once_with()
perm_man.grant_automatic_permissions_for_user.assert_called_once_with(
'mlogin')
self.assertDictEqual(user, {'created': 'user'})