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'})