def test_dbrole_delete_fail(self, mock_exists):
mock_exists.return_value = True
try:
role = DatabaseRole(MASTER_ROLE_NAME)
role.delete()
self.fail('Deleting a role was successful.')
except CommandError, err:
self.assertEqual(str(err),
"Role cannot be deleted: %s" % MASTER_ROLE_NAME)
def test_dbrole_revoke_fail(self):
try:
user = Mock()
user.username = TEST_USER_NAME1
user.has_role.return_value = True
role = DatabaseRole(MASTER_ROLE_NAME)
role.revoke(user)
self.fail('Revoking a role was successful.')
except CommandError, err:
self.assertEqual(str(err),
"Role cannot be revoked: %s" % MASTER_ROLE_NAME)
def handle(self, *args, **options):
check_database_engine()
username, rolename = parse_username_and_rolename(args)
role = DatabaseRole(rolename)
user = DatabaseUser(username, create=False)
role.revoke(user)
user.delete()
print "User '%s' deleted successfully." % username
def handle(self, *args, **options):
check_database_engine()
username, rolename = parse_username_and_rolename(args)
password = options.get('password')
no_password = options.get('no_password')
if not no_password and password is None:
self._ask_password()
role = DatabaseRole(rolename)
user = DatabaseUser(username, password)
role.grant(user)
print "User '%s' created successfully based on role '%s'." % (username,
rolename)
def handle(self, *args, **options):
check_database_engine()
username, rolename = parse_username_and_rolename(args)
password = options.get('password')
no_password = options.get('no_password')
if not no_password and password is None:
self._ask_password()
role = DatabaseRole(rolename)
user = DatabaseUser(username, password)
role.grant(user)
print "User '%s' created successfully based on role '%s'." % (
username, rolename)
def handle(self, *args, **options):
check_database_engine()
if len(args) < 1:
rolename = get_rolename_from_settings()
elif len(args) == 1:
rolename = args[0]
else:
raise CommandError('Too many arguments.')
role = DatabaseRole(rolename)
roles = role.get_users()
if not roles:
print "No users exist for role: %s" % rolename
else:
for role in roles:
print role
def test_dbrole_create_fail(self, mock_exists):
mock_exists.return_value = False
try:
DatabaseRole('dummy', create=True)
self.fail('Creating a role was successful.')
except CommandError, err:
self.assertEqual(str(err), "Role couldn't be created: dummy")
def setUp(self):
test_settings = {
'DATABASE_USER': '******',
'DATABASE_PASSWORD': '',
}
if hasattr(settings, 'DATABASES'):
test_settings['DATABASES'] = settings.DATABASES.copy()
test_settings['DATABASES']['default'].update({
'USER': '******',
'PASSWORD': '',
})
self.old_settings = switch_settings(**test_settings)
self._refresh_connection()
self._capture_stdout_stderr()
self._create_roles_and_users()
# Make sure that dummy role doesn't exist before testing starts.
if DatabaseRole.exists('dummy'):
DatabaseRole('dummy', create=False).delete()
def _create_roles_and_users(self):
# Create master role
if not DatabaseRole.exists(MASTER_ROLE_NAME):
self.master_role = DatabaseRole(MASTER_ROLE_NAME, create=True)
else:
self.master_role = DatabaseRole(MASTER_ROLE_NAME, create=False)
# Create standalone role (test1)
if not DatabaseRole.exists(EMPTY_ROLE_NAME):
self.empty_role = DatabaseRole(EMPTY_ROLE_NAME, create=True)
else:
self.empty_role = DatabaseRole(EMPTY_ROLE_NAME, create=False)
# Create users based on master tole (test2 and test3)
if not DatabaseUser.exists(TEST_USER_NAME1):
self.test1 = DatabaseUser(TEST_USER_NAME1, 'testpass', create=True)
else:
self.test1 = DatabaseUser(TEST_USER_NAME1, 'testpass', create=False)
self.master_role.grant(self.test1)
if not DatabaseUser.exists(TEST_USER_NAME2):
self.test2 = DatabaseUser(TEST_USER_NAME2, create=True)
else:
self.test2 = DatabaseUser(TEST_USER_NAME2, create=False)
self.master_role.grant(self.test2)
def _delete_roles_and_users(self):
# clean up everything
if DatabaseUser.exists(TEST_USER_NAME1):
if DatabaseRole.exists(MASTER_ROLE_NAME):
self.master_role.revoke(self.test1)
self.test1.delete()
if DatabaseUser.exists(TEST_USER_NAME2):
if DatabaseRole.exists(MASTER_ROLE_NAME):
self.master_role.revoke(self.test2)
self.test2.delete()
if DatabaseRole.exists(MASTER_ROLE_NAME):
self.master_role.delete()
if DatabaseRole.exists(EMPTY_ROLE_NAME):
self.empty_role.delete()
# make sure everything has been cleaned up
self.assertFalse(DatabaseUser.exists(TEST_USER_NAME1))
self.assertFalse(DatabaseUser.exists(TEST_USER_NAME2))
self.assertFalse(DatabaseRole.exists(MASTER_ROLE_NAME))
self.assertFalse(DatabaseRole.exists(EMPTY_ROLE_NAME))
class CommandTestCase(TestCase):
def setUp(self):
test_settings = {
'DATABASE_USER': '******',
'DATABASE_PASSWORD': '',
}
if hasattr(settings, 'DATABASES'):
test_settings['DATABASES'] = settings.DATABASES.copy()
test_settings['DATABASES']['default'].update({
'USER': '******',
'PASSWORD': '',
})
self.old_settings = switch_settings(**test_settings)
self._refresh_connection()
self._capture_stdout_stderr()
self._create_roles_and_users()
# Make sure that dummy role doesn't exist before testing starts.
if DatabaseRole.exists('dummy'):
DatabaseRole('dummy', create=False).delete()
def _refresh_connection(self):
for attname in ['HOST', 'PORT', 'NAME', 'USER', 'PASSWORD']:
if hasattr(settings, 'DATABASES'):
attvalue = settings.DATABASES['default'].get(attname, '')
# need to update the DatabaseWrapper cached settings_dict
# to keep up to date with the new db setting
connection.settings_dict[attname] = attvalue
elif hasattr(connection, 'settings_dict'):
setting_name = "DATABASE_%s" % attname
attvalue = getattr(settings, setting_name, '')
# need to update the DatabaseWrapper cached settings_dict
# to keep up to date with the new db setting
connection.settings_dict[setting_name] = attvalue
else:
# Django 1.0 doesn't have setting cache, so there's nothing to
# refresh
pass
connection.close()
def _capture_stdout_stderr(self):
# patch stdout and stderr to avoid polluting the console
sys.stdout = StringIO()
sys.stderr = StringIO()
def _create_roles_and_users(self):
# Create master role
if not DatabaseRole.exists(MASTER_ROLE_NAME):
self.master_role = DatabaseRole(MASTER_ROLE_NAME, create=True)
else:
self.master_role = DatabaseRole(MASTER_ROLE_NAME, create=False)
# Create standalone role (test1)
if not DatabaseRole.exists(EMPTY_ROLE_NAME):
self.empty_role = DatabaseRole(EMPTY_ROLE_NAME, create=True)
else:
self.empty_role = DatabaseRole(EMPTY_ROLE_NAME, create=False)
# Create users based on master tole (test2 and test3)
if not DatabaseUser.exists(TEST_USER_NAME1):
self.test1 = DatabaseUser(TEST_USER_NAME1, 'testpass', create=True)
else:
self.test1 = DatabaseUser(TEST_USER_NAME1, 'testpass', create=False)
self.master_role.grant(self.test1)
if not DatabaseUser.exists(TEST_USER_NAME2):
self.test2 = DatabaseUser(TEST_USER_NAME2, create=True)
else:
self.test2 = DatabaseUser(TEST_USER_NAME2, create=False)
self.master_role.grant(self.test2)
def tearDown(self):
self._delete_roles_and_users()
self._release_stdout_stderr()
switch_settings(**self.old_settings)
def _delete_roles_and_users(self):
# clean up everything
if DatabaseUser.exists(TEST_USER_NAME1):
if DatabaseRole.exists(MASTER_ROLE_NAME):
self.master_role.revoke(self.test1)
self.test1.delete()
if DatabaseUser.exists(TEST_USER_NAME2):
if DatabaseRole.exists(MASTER_ROLE_NAME):
self.master_role.revoke(self.test2)
self.test2.delete()
if DatabaseRole.exists(MASTER_ROLE_NAME):
self.master_role.delete()
if DatabaseRole.exists(EMPTY_ROLE_NAME):
self.empty_role.delete()
# make sure everything has been cleaned up
self.assertFalse(DatabaseUser.exists(TEST_USER_NAME1))
self.assertFalse(DatabaseUser.exists(TEST_USER_NAME2))
self.assertFalse(DatabaseRole.exists(MASTER_ROLE_NAME))
self.assertFalse(DatabaseRole.exists(EMPTY_ROLE_NAME))
def _release_stdout_stderr(self):
# reset stdout/stderr
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
def test_dbrole_query_missing_role(self):
try:
DatabaseRole('somefunkynonexistingrole')
self.fail("Role shouldn't exist.")
except CommandError:
pass
def test_dbrole_create_existing_role(self):
try:
DatabaseRole(MASTER_ROLE_NAME, create=True)
self.fail('Creating an existing role was successful.')
except CommandError:
pass