def test_modify_user_invalidates_cache(self, keystone_mock):
fake_user = fakes.FakeUser('abc123', '*****@*****.**',
'abc123 name')
# first cache an empty list
keystone_mock.users.list.return_value = []
self.assertEqual({}, self.cloud.get_user_cache())
# now add one
keystone_mock.users.list.return_value = [fake_user]
keystone_mock.users.create.return_value = fake_user
created = self.cloud.create_user(name='abc123 name',
email='*****@*****.**')
self.assertEqual(
{
'id': 'abc123',
'name': 'abc123 name',
'email': '*****@*****.**'
}, created)
# Cache should have been invalidated
self.assertEqual({'abc123': fake_user}, self.cloud.get_user_cache())
# Update and check to see if it is updated
fake_user2 = fakes.FakeUser('abc123', 'abc123 name',
'*****@*****.**')
keystone_mock.users.update.return_value = fake_user2
keystone_mock.users.list.return_value = [fake_user2]
self.cloud.update_user('abc123', email='*****@*****.**')
keystone_mock.users.update.assert_called_with(
user=fake_user2, email='*****@*****.**')
self.assertEqual({'abc123': fake_user2}, self.cloud.get_user_cache())
# Now delete and ensure it disappears
keystone_mock.users.list.return_value = []
self.cloud.delete_user('abc123')
self.assertEqual({}, self.cloud.get_user_cache())
self.assertTrue(keystone_mock.users.delete.was_called)
def test_delete_user(self, mock_keystone, mock_get_user, mock_get_by_id):
mock_get_user.return_value = dict(id='123')
fake_user = fakes.FakeUser('123', 'email', 'name')
mock_get_by_id.return_value = fake_user
self.assertTrue(self.op_cloud.delete_user('name'))
mock_get_by_id.assert_called_once_with('123', normalize=False)
mock_keystone.users.delete.assert_called_once_with(user=fake_user)
def test_list_users(self, keystone_mock):
fake_user = fakes.FakeUser('999', '', '')
keystone_mock.users.list.return_value = [fake_user]
users = self.cloud.list_users()
self.assertEqual(1, len(users))
self.assertEqual('999', users[0]['id'])
self.assertEqual('', users[0]['name'])
self.assertEqual('', users[0]['email'])
def test_modify_user_invalidates_cache(self, keystone_mock):
self.use_keystone_v2()
fake_user = fakes.FakeUser('abc123', '*****@*****.**',
'abc123 name')
# first cache an empty list
keystone_mock.users.list.return_value = []
self.assertEqual([], self.cloud.list_users())
# now add one
keystone_mock.users.list.return_value = [fake_user]
keystone_mock.users.create.return_value = fake_user
created = self.cloud.create_user(name='abc123 name',
email='*****@*****.**')
self.assertEqual('abc123', created['id'])
self.assertEqual('abc123 name', created['name'])
self.assertEqual('*****@*****.**', created['email'])
# Cache should have been invalidated
users = self.cloud.list_users()
self.assertEqual(1, len(users))
self.assertEqual('abc123', users[0]['id'])
self.assertEqual('abc123 name', users[0]['name'])
self.assertEqual('*****@*****.**', users[0]['email'])
# Update and check to see if it is updated
fake_user2 = fakes.FakeUser('abc123',
'*****@*****.**',
'abc123 name')
fake_user2_dict = meta.obj_to_dict(fake_user2)
keystone_mock.users.update.return_value = fake_user2
keystone_mock.users.list.return_value = [fake_user2]
keystone_mock.users.get.return_value = fake_user2_dict
self.cloud.update_user('abc123', email='*****@*****.**')
keystone_mock.users.update.assert_called_with(
user=fake_user2_dict, email='*****@*****.**')
users = self.cloud.list_users()
self.assertEqual(1, len(users))
self.assertEqual('abc123', users[0]['id'])
self.assertEqual('abc123 name', users[0]['name'])
self.assertEqual('*****@*****.**', users[0]['email'])
# Now delete and ensure it disappears
keystone_mock.users.list.return_value = []
self.cloud.delete_user('abc123')
self.assertEqual([], self.cloud.list_users())
self.assertTrue(keystone_mock.users.delete.was_called)
def test_create_user_v2(self, mock_keystone, mock_api_version):
mock_api_version.return_value = '2'
name = 'Mickey Mouse'
email = '*****@*****.**'
password = '******'
fake_user = fakes.FakeUser('1', email, name)
mock_keystone.users.create.return_value = fake_user
user = self.cloud.create_user(name=name, email=email,
password=password)
mock_keystone.users.create.assert_called_once_with(
name=name, password=password, email=email, enabled=True,
)
self.assertEqual(name, user.name)
self.assertEqual(email, user.email)
def test_grant_both_project_and_domain(self, mock_keystone,
mock_api_version):
mock_api_version.return_value = '3'
fake_user2 = fakes.FakeUser('12345',
'*****@*****.**',
'test',
domain_id='default')
mock_keystone.roles.list.return_value = [self.fake_role]
mock_keystone.users.list.return_value = [self.fake_user, fake_user2]
mock_keystone.projects.list.return_value = [self.fake_project]
mock_keystone.domains.get.return_value = self.fake_domain
self.assertTrue(
self.op_cloud.grant_role(self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id'],
domain=self.fake_domain['name']))
def test_create_user_v3(self, mock_keystone, mock_api_version):
mock_api_version.return_value = '3'
name = 'Mickey Mouse'
email = '*****@*****.**'
password = '******'
domain_id = '456'
description = 'fake-description'
fake_user = fakes.FakeUser('1', email, name, description=description)
mock_keystone.users.create.return_value = fake_user
user = self.op_cloud.create_user(
name=name, email=email,
password=password,
description=description,
domain_id=domain_id)
mock_keystone.users.create.assert_called_once_with(
name=name, password=password, email=email,
description=description, enabled=True,
domain=domain_id
)
self.assertEqual(name, user.name)
self.assertEqual(email, user.email)
self.assertEqual(description, user.description)
def test_update_user_password_v2(self, mock_keystone, mock_api_version):
mock_api_version.return_value = '2'
name = 'Mickey Mouse'
email = '*****@*****.**'
password = '******'
domain_id = '1'
user = {'id': '1', 'name': name, 'email': email}
fake_user = fakes.FakeUser(**user)
munch_fake_user = munch.Munch(user)
mock_keystone.users.list.return_value = [fake_user]
mock_keystone.users.get.return_value = fake_user
mock_keystone.users.update.return_value = fake_user
mock_keystone.users.update_password.return_value = fake_user
user = self.cloud.update_user(name, name=name, email=email,
password=password,
domain_id=domain_id)
mock_keystone.users.update.assert_called_once_with(
user=munch_fake_user, name=name, email=email)
mock_keystone.users.update_password.assert_called_once_with(
user=munch_fake_user, password=password)
self.assertEqual(name, user.name)
self.assertEqual(email, user.email)
def test_get_user_cache(self, keystone_mock):
fake_user = fakes.FakeUser('999', '', '')
keystone_mock.users.list.return_value = [fake_user]
self.assertEqual({'999': fake_user}, self.cloud.get_user_cache())
def setUp(self):
super(TestRoleAssignment, self).setUp()
self.fake_role = obj_to_dict(fakes.FakeRole('12345', 'test'))
self.fake_user = obj_to_dict(
fakes.FakeUser('12345',
'*****@*****.**',
'test',
domain_id='test-domain'))
self.fake_group = obj_to_dict(
fakes.FakeGroup('12345',
'test',
'test group',
domain_id='test-domain'))
self.fake_project = obj_to_dict(
fakes.FakeProject('12345', domain_id='test-domain'))
self.fake_domain = obj_to_dict(
fakes.FakeDomain('test-domain',
'test',
'test domain',
enabled=True))
self.user_project_assignment = obj_to_dict({
'role': {
'id': self.fake_role['id']
},
'scope': {
'project': {
'id': self.fake_project['id']
}
},
'user': {
'id': self.fake_user['id']
}
})
self.group_project_assignment = obj_to_dict({
'role': {
'id': self.fake_role['id']
},
'scope': {
'project': {
'id': self.fake_project['id']
}
},
'group': {
'id': self.fake_group['id']
}
})
self.user_domain_assignment = obj_to_dict({
'role': {
'id': self.fake_role['id']
},
'scope': {
'domain': {
'id': self.fake_domain['id']
}
},
'user': {
'id': self.fake_user['id']
}
})
self.group_domain_assignment = obj_to_dict({
'role': {
'id': self.fake_role['id']
},
'scope': {
'domain': {
'id': self.fake_domain['id']
}
},
'group': {
'id': self.fake_group['id']
}
})
