def test_signal_calls_metadata_update(self, mock_get, mock_signal,
mock_update, mock_get_cfn):
mock_get_cfn.return_value = 'http://server.test:8000/v1'
# fake keystone client
self.patchobject(keystone.KeystoneClientPlugin,
'_create',
return_value=fake_ks.FakeKeystoneClient())
stk = tools.get_stack('signal_reception', self.ctx, policy_template)
self.stack = stk
stk.store()
stk.create()
s = stack_object.Stack.get_by_id(self.ctx, self.stack.id)
mock_get.return_value = s
mock_signal.return_value = True
# this will be called once for the Random resource
mock_update.return_value = None
self.eng.resource_signal(self.ctx,
dict(self.stack.identifier()),
'WebServerScaleDownPolicy',
None,
sync_call=True)
mock_get.assert_called_once_with(self.ctx, self.stack.identifier())
mock_signal.assert_called_once_with(mock.ANY, False)
mock_update.assert_called_once_with()
def test_signal_no_calls_metadata_update(self, mock_get, mock_signal,
mock_update):
# fake keystone client
self.patchobject(keystone.KeystoneClientPlugin,
'_create',
return_value=fake_ks.FakeKeystoneClient())
stk = tools.get_stack('signal_reception', self.ctx, policy_template)
self.stack = stk
stk.store()
stk.create()
s = stack_object.Stack.get_by_id(self.ctx, self.stack.id)
mock_get.return_value = s
mock_signal.return_value = False
self.eng.resource_signal(self.ctx,
dict(self.stack.identifier()),
'WebServerScaleDownPolicy',
None,
sync_call=True)
mock_get.assert_called_once_with(self.ctx, self.stack.identifier())
mock_signal.assert_called_once_with(mock.ANY, False)
# this will never be called
self.assertEqual(0, mock_update.call_count)
def setUp(self):
super(KeystoneGroupTest, self).setUp()
self.ctx = utils.dummy_context()
self.stack = stack.Stack(
self.ctx, 'test_stack_keystone',
template.Template(keystone_group_template)
)
self.test_group = self.stack['test_group']
# Mock client
self.keystoneclient = mock.Mock()
self.patchobject(resource.Resource, 'client',
return_value=fake_ks.FakeKeystoneClient(
client=self.keystoneclient))
self.groups = self.keystoneclient.groups
self.role_assignments = self.keystoneclient.role_assignments
# Mock client plugin
def _side_effect(value):
return value
self.keystone_client_plugin = mock.MagicMock()
(self.keystone_client_plugin.get_domain_id.
side_effect) = _side_effect
self.test_group.client_plugin = mock.MagicMock()
(self.test_group.client_plugin.
return_value) = self.keystone_client_plugin
def test_create_keypair(self):
stack_name = 'stackuser_test_cr_keypair'
project_id = 'aprojectdel'
user_id = 'auserdel'
rsrc = self._user_create(stack_name=stack_name,
project_id=project_id,
user_id=user_id)
creds = fake_ks.FakeKeystoneClient().creds
self.fc.creds = creds
self.fc.credential_id = creds.id
self.fc.access = creds.access
self.fc.secret = creds.secret
# create_stack_domain_user_keypair(self, user_id, project_id):
self.fc.create_stack_domain_user_keypair.return_value = self.fc.creds
scheduler.TaskRunner(rsrc.create)()
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
kp = rsrc._create_keypair()
self.assertEqual(self.fc.credential_id, kp.id)
self.assertEqual(self.fc.access, kp.access)
self.assertEqual(self.fc.secret, kp.secret)
rs_data = resource_data_object.ResourceData.get_all(rsrc)
self.assertEqual(self.fc.credential_id, rs_data['credential_id'])
self.assertEqual(self.fc.access, rs_data['access_key'])
self.assertEqual(self.fc.secret, rs_data['secret_key'])
self.fc.create_stack_domain_user_keypair.assert_called_once_with(
project_id=project_id, user_id=user_id)
def test_delete_deletes_project(self):
fkc = fake_ks.FakeKeystoneClient()
fkc.delete_stack_domain_project = mock.Mock()
mock_kcp = self.patchobject(keystone.KeystoneClientPlugin,
'_create',
return_value=fkc)
self.stack = stack.Stack(self.ctx, 'delete_trust', self.tmpl)
stack_id = self.stack.store()
self.stack.set_stack_user_project_id(project_id='aproject456')
db_s = stack_object.Stack.get_by_id(self.ctx, stack_id)
self.assertIsNotNone(db_s)
self.stack.delete()
mock_kcp.assert_called_with()
db_s = stack_object.Stack.get_by_id(self.ctx, stack_id)
self.assertIsNone(db_s)
self.assertEqual((stack.Stack.DELETE, stack.Stack.COMPLETE),
self.stack.state)
fkc.delete_stack_domain_project.assert_called_once_with(
project_id='aproject456')
def test_delete_trust_not_trustor(self):
# Stack gets created with trustor_ctx, deleted with other_ctx
# then the trust delete should be with stored_ctx
trustor_ctx = utils.dummy_context(user_id='thetrustor')
other_ctx = utils.dummy_context(user_id='nottrustor')
stored_ctx = utils.dummy_context(trust_id='thetrust')
mock_kc = self.patchobject(hkc, 'KeystoneClient')
self.stub_keystoneclient(user_id='thetrustor')
mock_sc = self.patchobject(stack.Stack, 'stored_context')
mock_sc.return_value = stored_ctx
self.stack = stack.Stack(trustor_ctx, 'delete_trust_nt', self.tmpl)
stack_id = self.stack.store()
db_s = stack_object.Stack.get_by_id(self.ctx, stack_id)
self.assertIsNotNone(db_s)
user_creds_id = db_s.user_creds_id
self.assertIsNotNone(user_creds_id)
user_creds = ucreds_object.UserCreds.get_by_id(self.ctx, user_creds_id)
self.assertEqual('thetrustor', user_creds.get('trustor_user_id'))
mock_kc.return_value = fake_ks.FakeKeystoneClient(user_id='nottrustor')
loaded_stack = stack.Stack.load(other_ctx, self.stack.id)
loaded_stack.delete()
mock_sc.assert_called_with()
db_s = stack_object.Stack.get_by_id(other_ctx, stack_id)
self.assertIsNone(db_s)
self.assertEqual((stack.Stack.DELETE, stack.Stack.COMPLETE),
loaded_stack.state)
def setUp(self):
super(AccessKeyTest, self).setUp()
self.username = utils.PhysName('test_stack', 'CfnUser')
self.credential_id = 'acredential123'
self.fc = fake_ks.FakeKeystoneClient(username=self.username,
user_id='dummy_user',
credential_id=self.credential_id)
cfg.CONF.set_default('heat_stack_user_role', 'stack_user_role')
def _stack_create(self, stack_name):
self.patchobject(keystone.KeystoneClientPlugin, '_create',
return_value=fake_ks.FakeKeystoneClient())
stk = tools.get_stack(stack_name, self.ctx, policy_template)
stk.store()
stk.create()
s = stack_object.Stack.get_by_id(self.ctx, stk.id)
self.patchobject(service.EngineService, '_get_stack', return_value=s)
return stk
def setUp(self):
super(KeystoneRoleTest, self).setUp()
self.ctx = utils.dummy_context()
# Mock client
self.keystoneclient = mock.Mock()
self.patchobject(resource.Resource,
'client',
return_value=fake_ks.FakeKeystoneClient(
client=self.keystoneclient))
self.roles = self.keystoneclient.roles
def setUp(self):
super(KeystoneServiceTest, self).setUp()
self.ctx = utils.dummy_context()
# Mock client
self.keystoneclient = mock.Mock()
self.patchobject(resource.Resource, 'client',
return_value=fake_ks.FakeKeystoneClient(
client=self.keystoneclient))
self.services = self.keystoneclient.services
# Mock client plugin
self.keystone_client_plugin = mock.MagicMock()
def setUp(self):
super(KeystoneGroupRoleAssignmentTest, self).setUp()
self.ctx = utils.dummy_context()
self.stack = stack.Stack(
self.ctx, 'test_stack_keystone_group_role_add',
template.Template(self.role_assignment_template))
self.test_role_assignment = self.stack['test_role_assignment']
# Mock client
self.keystoneclient = mock.Mock()
self.patchobject(resource.Resource,
'client',
return_value=fake_ks.FakeKeystoneClient(
client=self.keystoneclient))
self.roles = self.keystoneclient.roles
# Mock client plugin
def _side_effect(value):
return value
self.keystone_client_plugin = mock.MagicMock()
self.keystone_client_plugin.get_group_id.side_effect = _side_effect
self.keystone_client_plugin.get_domain_id.side_effect = _side_effect
self.keystone_client_plugin.get_role_id.side_effect = _side_effect
self.keystone_client_plugin.get_project_id.side_effect = _side_effect
self.test_role_assignment.client_plugin = mock.MagicMock()
(self.test_role_assignment.client_plugin.return_value
) = self.keystone_client_plugin
self.test_role_assignment.parse_list_assignments = mock.MagicMock()
self.test_role_assignment.parse_list_assignments.return_value = [{
'role':
'role_1',
'domain':
'domain_1',
'project':
None
}, {
'role':
'role_1',
'project':
'project_1',
'domain':
None
}]
def setUp(self):
super(KeystoneRegionTest, self).setUp()
self.ctx = utils.dummy_context()
self.stack = stack.Stack(self.ctx, 'test_stack_keystone',
template.Template(KEYSTONE_REGION_TEMPLATE))
self.test_region = self.stack['test_region']
# Mock client
self.keystoneclient = mock.Mock()
self.patchobject(resource.Resource,
'client',
return_value=fake_ks.FakeKeystoneClient(
client=self.keystoneclient))
self.regions = self.keystoneclient.regions
keystone_client_plugin = mock.MagicMock()
self.test_region.client_plugin = mock.MagicMock()
self.test_region.client_plugin.return_value = keystone_client_plugin
def setup_keystone_mocks_with_mock(test_case, stack):
fkc = fake_ks.FakeKeystoneClient()
test_case.patchobject(keystone.KeystoneClientPlugin, '_create')
keystone.KeystoneClientPlugin._create.return_value = fkc
def stub_keystoneclient(self, fake_client=None, **kwargs):
client = self.patchobject(keystone.KeystoneClientPlugin, "_create")
fkc = fake_client or fake_ks.FakeKeystoneClient(**kwargs)
client.return_value = fkc
return fkc
def setup_keystone_mocks(mocks, stack):
fkc = fake_ks.FakeKeystoneClient()
mocks.StubOutWithMock(keystone.KeystoneClientPlugin, '_create')
keystone.KeystoneClientPlugin._create().AndReturn(fkc)
def setUp(self):
super(UserTest, self).setUp()
self.stack_name = 'test_user_stack_%s' % utils.random_name()
self.username = '******' % self.stack_name
self.fc = fake_ks.FakeKeystoneClient(username=self.username)
cfg.CONF.set_default('heat_stack_user_role', 'stack_user_role')
def setUp(self):
super(StackUserTest, self).setUp()
self.fc = fake_ks.FakeKeystoneClient()