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 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 _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 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 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 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