def test_revoke_access(self):
usr1 = models.CassandraUser('usr1')
usr2 = models.CassandraUser('usr1', 'password')
db1 = models.CassandraSchema('db1')
db2 = models.CassandraSchema('db2')
self.manager.revoke_access(self.context, usr1.name, None, db1.name)
self.manager.revoke_access(self.context, usr2.name, None, db2.name)
self.conn.execute.assert_has_calls([
call(self.__REVOKE_FORMAT, (db1.name, usr1.name)),
call(self.__REVOKE_FORMAT, (db2.name, usr2.name))
])
def test_create_database(self):
db1 = models.CassandraSchema('db1')
db2 = models.CassandraSchema('db2')
db3 = models.CassandraSchema(self._get_random_name(32))
self.manager.create_database(self.context,
self._serialize_collection(db1, db2, db3))
self.conn.execute.assert_has_calls([
call(self.__CREATE_DB_FORMAT, (db1.name, )),
call(self.__CREATE_DB_FORMAT, (db2.name, )),
call(self.__CREATE_DB_FORMAT, (db3.name, ))
])
def test_list_databases(self):
db1 = models.CassandraSchema('db1')
db2 = models.CassandraSchema('db2')
db3 = models.CassandraSchema(self._get_random_name(32))
with patch.object(self.admin,
self.__N_GAK,
return_value={db1, db2, db3}):
found = self.manager.list_databases(self.context)
self.assertEqual(2, len(found))
self.assertEqual(3, len(found[0]))
self.assertIsNone(found[1])
self.assertIn(db1.serialize(), found[0])
self.assertIn(db2.serialize(), found[0])
self.assertIn(db3.serialize(), found[0])
with patch.object(self.admin, self.__N_GAK, return_value=set()):
found = self.manager.list_databases(self.context)
self.assertEqual(([], None), found)
def test_grant_access(self):
usr1 = models.CassandraUser('usr1')
usr2 = models.CassandraUser('usr1', 'password')
db1 = models.CassandraSchema('db1')
db2 = models.CassandraSchema('db2')
db3 = models.CassandraSchema('db3')
self.manager.grant_access(self.context, usr1.name, None,
[db1.name, db2.name])
self.manager.grant_access(self.context, usr2.name, None, [db3.name])
expected = []
for modifier in self.__ACCESS_MODIFIERS:
expected.append(
call(self.__GRANT_FORMAT, (modifier, db1.name, usr1.name)))
expected.append(
call(self.__GRANT_FORMAT, (modifier, db3.name, usr2.name)))
self.conn.execute.assert_has_calls(expected, any_order=True)
def test_rename_user(self, ks_deserializer):
usr = models.CassandraUser('usr')
db1 = models.CassandraSchema('db1').serialize()
db2 = models.CassandraSchema('db2').serialize()
usr.databases.append(db1)
usr.databases.append(db2)
new_user = models.CassandraUser('new_user')
with patch(self.__N_CAU, return_value=new_user):
with patch.object(self.admin, self.__N_BU, return_value=usr):
with patch.object(self.admin, self.__N_CU) as create:
with patch.object(self.admin, self.__N_GFA) as grant:
with patch.object(self.admin, self.__N_DU) as drop:
usr_attrs = {'name': 'user', 'password': '******'}
self.manager.update_attributes(
self.context, usr.name, None, usr_attrs)
create.assert_called_once_with(ANY, new_user)
grant.assert_has_calls(
[call(ANY, db1, ANY),
call(ANY, db2, ANY)])
drop.assert_called_once_with(ANY, usr)
def test_get_listed_users(self):
usr1 = models.CassandraUser(self._get_random_name(1025))
usr2 = models.CassandraUser(self._get_random_name(1025))
usr3 = models.CassandraUser(self._get_random_name(1025))
db1 = models.CassandraSchema('db1')
db2 = models.CassandraSchema('db2')
usr1.databases.append(db1.serialize())
usr3.databases.append(db2.serialize())
rv_1 = NonCallableMagicMock()
rv_1.configure_mock(name=usr1.name, super=False)
rv_2 = NonCallableMagicMock()
rv_2.configure_mock(name=usr2.name, super=False)
rv_3 = NonCallableMagicMock()
rv_3.configure_mock(name=usr3.name, super=True)
with patch.object(self.conn,
'execute',
return_value=iter([rv_1, rv_2, rv_3])):
with patch.object(self.admin,
'_get_acl',
return_value={
usr1.name: {
db1.name: {'SELECT'},
db2.name: {}
},
usr3.name: {
db2.name: {'SELECT'}
}
}):
usrs = self.manager.list_users(self.context)
self.conn.execute.assert_has_calls([
call(self.__LIST_USR_FORMAT),
],
any_order=True)
self.assertIn(usr1.serialize(), usrs[0])
self.assertIn(usr2.serialize(), usrs[0])
self.assertIn(usr3.serialize(), usrs[0])
def test_list_access(self):
usr1 = models.CassandraUser('usr1')
usr2 = models.CassandraUser('usr2')
usr3 = models.CassandraUser(self._get_random_name(1025), 'password')
db1 = models.CassandraSchema('db1').serialize()
db2 = models.CassandraSchema('db2').serialize()
usr2.databases.append(db1)
usr3.databases.append(db1)
usr3.databases.append(db2)
with patch.object(self.admin,
self.__N_GLU,
return_value={usr1, usr2, usr3}):
usr1_dbs = self.manager.list_access(self.context, usr1.name, None)
usr2_dbs = self.manager.list_access(self.context, usr2.name, None)
usr3_dbs = self.manager.list_access(self.context, usr3.name, None)
self.assertEqual([], usr1_dbs)
self.assertEqual([db1], usr2_dbs)
self.assertEqual([db1, db2], usr3_dbs)
with patch.object(self.admin, self.__N_GLU, return_value=set()):
with ExpectedException(exception.UserNotFound):
self.manager.list_access(self.context, usr3.name, None)
def test_get_acl(self):
r0 = NonCallableMagicMock(username='******',
resource='<all keyspaces>',
permission='SELECT')
r1 = NonCallableMagicMock(username='******',
resource='<keyspace ks1>',
permission='SELECT')
r2 = NonCallableMagicMock(username='******',
resource='<keyspace ks2>',
permission='SELECT')
r3 = NonCallableMagicMock(username='******',
resource='<keyspace ks2>',
permission='ALTER')
r4 = NonCallableMagicMock(username='******',
resource='<table ks2.t1>',
permission='SELECT')
r5 = NonCallableMagicMock(username='******',
resource='',
permission='ALTER')
r6 = NonCallableMagicMock(username='******',
resource='<keyspace ks2>',
permission='')
r7 = NonCallableMagicMock(username='******', resource='', permission='')
r8 = NonCallableMagicMock(username='******',
resource='<keyspace ks1>',
permission='DELETE')
r9 = NonCallableMagicMock(username='******',
resource='<all keyspaces>',
permission='UPDATE')
r10 = NonCallableMagicMock(username='******',
resource='<keyspace ks1>',
permission='DELETE')
available_ks = {
models.CassandraSchema('ks1'),
models.CassandraSchema('ks2'),
models.CassandraSchema('ks3')
}
mock_result_set = [r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r9, r9, r10]
execute_mock = MagicMock(return_value=mock_result_set)
mock_client = MagicMock(execute=execute_mock)
with patch.object(self.admin, self.__N_GAK,
return_value=available_ks) as gak_mock:
acl = self.admin._get_acl(mock_client)
execute_mock.assert_called_once_with(
self.__LIST_PERMISSIONS_FORMAT)
gak_mock.assert_called_once_with(mock_client)
self.assertEqual(
{
'user1': {
'ks1': {'SELECT'},
'ks2': {'SELECT'},
'ks3': {'SELECT'}
},
'user2': {
'ks1': {'SELECT'},
'ks2': {'SELECT', 'ALTER'}
},
'user3': {
'ks1': {'DELETE'}
},
'user4': {
'ks1': {'UPDATE', 'DELETE'},
'ks2': {'UPDATE'},
'ks3': {'UPDATE'}
}
}, acl)
mock_result_set = [r1, r2, r3]
execute_mock = MagicMock(return_value=mock_result_set)
mock_client = MagicMock(execute=execute_mock)
with patch.object(self.admin, self.__N_GAK,
return_value=available_ks) as gak_mock:
acl = self.admin._get_acl(mock_client, username='******')
execute_mock.assert_called_once_with(
self.__LIST_PERMISSIONS_OF_FORMAT.format('user2'))
gak_mock.assert_not_called()
self.assertEqual(
{'user2': {
'ks1': {'SELECT'},
'ks2': {'SELECT', 'ALTER'}
}}, acl)
mock_result_set = []
execute_mock = MagicMock(return_value=mock_result_set)
mock_client = MagicMock(execute=execute_mock)
with patch.object(self.admin, self.__N_GAK,
return_value=available_ks) as gak_mock:
acl = self.admin._get_acl(mock_client, username='******')
execute_mock.assert_called_once_with(
self.__LIST_PERMISSIONS_OF_FORMAT.format('nonexisting'))
gak_mock.assert_not_called()
self.assertEqual({}, acl)
def test_delete_database(self):
db = models.CassandraSchema(self._get_random_name(32))
self.manager.delete_database(self.context, db.serialize())
self.conn.execute.assert_called_once_with(self.__DROP_DB_FORMAT,
(db.name, ))
def test_keyspace_validation(self):
valid_name = self._get_random_name(32)
db = models.CassandraSchema(valid_name)
self.assertEqual(valid_name, db.name)
with ExpectedException(ValueError):
models.CassandraSchema(self._get_random_name(33))
