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 = fakes.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 test_purge_deleted(self):
now = datetime.now()
delta = timedelta(seconds=3600 * 7)
deleted = [now - delta * i for i in range(1, 6)]
templates = [create_raw_template(self.ctx) for i in range(5)]
creds = [create_user_creds(self.ctx) for i in range(5)]
stacks = [create_stack(self.ctx, templates[i], creds[i],
deleted_at=deleted[i]) for i in range(5)]
class MyDatetime():
def now(self):
return now
self.useFixture(fixtures.MonkeyPatch('heat.db.sqlalchemy.api.datetime',
MyDatetime()))
db_api.purge_deleted(age=1, granularity='days')
self._deleted_stack_existance(utils.dummy_context(), stacks,
(0, 1, 2), (3, 4))
db_api.purge_deleted(age=22, granularity='hours')
self._deleted_stack_existance(utils.dummy_context(), stacks,
(0, 1, 2), (3, 4))
db_api.purge_deleted(age=1100, granularity='minutes')
self._deleted_stack_existance(utils.dummy_context(), stacks,
(0, 1), (2, 3, 4))
db_api.purge_deleted(age=3600, granularity='seconds')
self._deleted_stack_existance(utils.dummy_context(), stacks,
(), (0, 1, 2, 3, 4))
def test_sync_with_time_throttle(self):
ctx = utils.dummy_context()
stack = tools.get_stack('test_stack', utils.dummy_context(),
template=tools.string_template_five,
convergence=True)
stack.converge_stack(stack.t, action=stack.CREATE)
mock_sleep_time = self.sync_with_sleep(ctx, stack)
mock_sleep_time.assert_called_once_with(mock.ANY)
def test_stack_create_no_credentials(self):
cfg.CONF.set_default('deferred_auth_method', 'password')
stack_name = 'test_stack_create_no_credentials'
params = {'foo': 'bar'}
template = '{ "Template": "data" }'
stk = tools.get_stack(stack_name, self.ctx)
# force check for credentials on create
stk['WebServer'].requires_deferred_auth = True
mock_tmpl = self.patchobject(templatem, 'Template', return_value=stk.t)
mock_env = self.patchobject(environment, 'Environment',
return_value=stk.env)
mock_stack = self.patchobject(stack, 'Stack', return_value=stk)
# test stack create using context without password
ctx_no_pwd = utils.dummy_context(password=None)
ex = self.assertRaises(dispatcher.ExpectedException,
self.man.create_stack,
ctx_no_pwd, stack_name,
template, params, None, {}, None)
self.assertEqual(exception.MissingCredentialError, ex.exc_info[0])
self.assertEqual('Missing required credential: X-Auth-Key',
six.text_type(ex.exc_info[1]))
mock_tmpl.assert_called_once_with(template, files=None, env=stk.env)
mock_env.assert_called_once_with(params)
mock_stack.assert_called_once_with(ctx_no_pwd, stack_name, stk.t,
owner_id=None, nested_depth=0,
user_creds_id=None,
stack_user_project_id=None,
convergence=False,
parent_resource=None)
mock_tmpl.reset_mock()
mock_env.reset_mock()
mock_stack.reset_mock()
# test stack create using context without user
ctx_no_pwd = utils.dummy_context(password=None)
ctx_no_user = utils.dummy_context(user=None)
ex = self.assertRaises(dispatcher.ExpectedException,
self.man.create_stack,
ctx_no_user, stack_name,
template, params, None, {})
self.assertEqual(exception.MissingCredentialError, ex.exc_info[0])
self.assertEqual('Missing required credential: X-Auth-User',
six.text_type(ex.exc_info[1]))
mock_tmpl.assert_called_once_with(template, files=None, env=stk.env)
mock_env.assert_called_once_with(params)
mock_stack.assert_called_once_with(ctx_no_user, stack_name, stk.t,
owner_id=None, nested_depth=0,
user_creds_id=None,
stack_user_project_id=None,
convergence=False,
parent_resource=None)
def test_check_admin(self):
enforcer = policy.Enforcer()
ctx = utils.dummy_context(roles=[])
self.assertFalse(enforcer.check_is_admin(ctx))
ctx = utils.dummy_context(roles=['not_admin'])
self.assertFalse(enforcer.check_is_admin(ctx))
ctx = utils.dummy_context(roles=['admin'])
self.assertTrue(enforcer.check_is_admin(ctx))
def test_updated_time(self, mock_cr):
stack = parser.Stack(utils.dummy_context(), 'convg_updated_time_test',
templatem.Template.create_empty_template())
stack.store()
stack.create()
self.assertIsNone(stack.updated_time)
tmpl = {'HeatTemplateFormatVersion': '2012-12-12',
'Resources': {'R1': {'Type': 'GenericResourceType'}}}
newstack = parser.Stack(utils.dummy_context(), 'updated_time_test',
templatem.Template(tmpl))
stack.update(newstack)
self.assertIsNotNone(stack.updated_time)
def test_resource_facade_missing_deletion_policy(self):
snippet = {"resource_facade": "deletion_policy"}
class DummyClass(object):
pass
parent_resource = DummyClass()
parent_resource.metadata = {"foo": "bar"}
parent_resource.t = {}
parent_resource.stack = parser.Stack(utils.dummy_context(), "toplevel_stack", parser.Template({}))
stack = parser.Stack(
utils.dummy_context(), "test_stack", parser.Template(hot_tpl_empty), parent_resource=parent_resource
)
self.assertEqual("Delete", self.resolve(snippet, stack.t, stack))
def test_nested_stack_delete_then_delete_parent_stack(self):
urlfetch.get("https://server.test/the.template").MultipleTimes().AndReturn(self.nested_template)
self.m.ReplayAll()
stack = self.create_stack(self.test_template)
rsrc = stack["the_nested"]
nested_stack = parser.Stack.load(utils.dummy_context("test_username", "aaaa", "password"), rsrc.resource_id)
nested_stack.delete()
stack = parser.Stack.load(utils.dummy_context("test_username", "aaaa", "password"), stack.id)
stack.delete()
self.assertEqual((stack.DELETE, stack.COMPLETE), stack.state)
self.m.VerifyAll()
def _setup_test_stack(self, stack_name):
t = template_format.parse(wp_template)
template = parser.Template(t)
stack = parser.Stack(utils.dummy_context(), stack_name, template,
{},
stack_id=uuidutils.generate_uuid())
return (t, stack)
def create_stack(self, stack_id=None,
template=test_template_heat_waitcondition_count,
params={},
stub=True, stub_status=True):
temp = template_format.parse(template)
template = parser.Template(temp)
ctx = utils.dummy_context(tenant_id=self.tenant_id)
stack = parser.Stack(ctx, 'test_stack', template,
environment.Environment(params),
disable_rollback=True)
# Stub out the stack ID so we have a known value
if stack_id is None:
stack_id = str(uuid.uuid4())
self.stack_id = stack_id
with utils.UUIDStub(self.stack_id):
stack.store()
if stub:
id = identifier.ResourceIdentifier('test_tenant', stack.name,
stack.id, '', 'wait_handle')
self.m.StubOutWithMock(wc.HeatWaitConditionHandle, 'identifier')
wc.HeatWaitConditionHandle.identifier().MultipleTimes().AndReturn(
id)
if stub_status:
self.m.StubOutWithMock(wc.HeatWaitConditionHandle,
'get_status')
return stack
def test_format_stack_outputs(self):
template = parser.Template({
'HeatTemplateFormatVersion': '2012-12-12',
'Resources': {
'generic': {'Type': 'GenericResourceType'}
},
'Outputs': {
'correct_output': {
'Description': 'Good output',
'Value': {'Fn::GetAtt': ['generic', 'Foo']}
},
'incorrect_output': {
'Value': {'Fn::GetAtt': ['generic', 'Bar']}
}
}
})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
template, stack_id=str(uuid.uuid4()))
stack.action = 'CREATE'
stack.status = 'COMPLETE'
stack['generic'].action = 'CREATE'
stack['generic'].status = 'COMPLETE'
info = api.format_stack_outputs(stack, stack.outputs)
expected = [{'description': 'No description given',
'output_error': 'The Referenced Attribute (generic Bar) '
'is incorrect.',
'output_key': 'incorrect_output',
'output_value': None},
{'description': 'Good output',
'output_key': 'correct_output',
'output_value': 'generic'}]
self.assertEqual(expected, info)
def test_validate(self):
mock_extension = self.patchobject(
neutron.NeutronClientPlugin, 'has_extension', return_value=True)
nc = mock.Mock()
mock_create = self.patchobject(neutron.NeutronClientPlugin, '_create')
mock_create.return_value = nc
mock_find = self.patchobject(neutron.NeutronClientPlugin,
'find_resourceid_by_name_or_id')
mock_find.side_effect = [
'foo',
qe.NeutronClientException(status_code=404)
]
constraint = self.constraint_class()
ctx = utils.dummy_context()
if hasattr(constraint, 'extension') and constraint.extension:
mock_extension.side_effect = [
False,
True,
True,
]
ex = self.assertRaises(
exception.EntityNotFound,
constraint.validate_with_client, ctx.clients, "foo"
)
expected = ("The neutron extension (%s) could not be found." %
constraint.extension)
self.assertEqual(expected, six.text_type(ex))
self.assertTrue(constraint.validate("foo", ctx))
self.assertFalse(constraint.validate("bar", ctx))
mock_find.assert_has_calls(
[mock.call(self.resource_type, 'foo',
cmd_resource=self.cmd_resource),
mock.call(self.resource_type, 'bar',
cmd_resource=self.cmd_resource)])
def parse_stack(self, t):
stack_name = 'test_stack'
tmpl = parser.Template(t)
stack = parser.Stack(utils.dummy_context(), stack_name, tmpl)
stack.validate()
stack.store()
return stack
def create_stack(self, stack_name=None, stack_id=None):
temp = template_format.parse(test_template_waitcondition)
template = parser.Template(temp)
ctx = utils.dummy_context(tenant_id='test_tenant')
if stack_name is None:
stack_name = utils.random_name()
stack = parser.Stack(ctx, stack_name, template,
disable_rollback=True)
# Stub out the UUID for this test, so we can get an expected signature
if stack_id is not None:
with utils.UUIDStub(stack_id):
stack.store()
else:
stack.store()
self.stack_id = stack.id
# Stub waitcondition status so all goes CREATE_COMPLETE
self.m.StubOutWithMock(wc.WaitConditionHandle, 'get_status')
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS'])
id = identifier.ResourceIdentifier('test_tenant', stack.name,
stack.id, '', 'WaitHandle')
self.m.StubOutWithMock(wc.WaitConditionHandle, 'identifier')
wc.WaitConditionHandle.identifier().MultipleTimes().AndReturn(id)
self.m.ReplayAll()
stack.create()
return stack
def test_user_template_retrieve_fail(self):
# make sure that a TemplateResource defined in the user environment
# fails gracefully if the template file specified is inaccessible
# we should be able to create the TemplateResource object, but
# validation should fail, when the second attempt to access it is
# made in validate()
env = environment.Environment()
test_templ_name = 'http://heatr/noexist.yaml'
env.load({'resource_registry':
{'Test::Flippy': test_templ_name}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template), env=env,
stack_id=str(uuid.uuid4()))
self.m.StubOutWithMock(urlfetch, "get")
urlfetch.get(test_templ_name,
allowed_schemes=('http', 'https'))\
.AndRaise(urlfetch.URLFetchError(_('Failed to retrieve template')))
self.m.ReplayAll()
definition = rsrc_defn.ResourceDefinition('test_t_res',
'Test::Flippy')
temp_res = template_resource.TemplateResource('test_t_res',
definition,
stack)
self.assertRaises(exception.StackValidationFailed, temp_res.validate)
self.m.VerifyAll()
def parse_stack(self, t, data=None):
ctx = utils.dummy_context('test_username', 'aaaa', 'password')
stack_name = 'test_stack'
tmpl = template.Template(t)
stack = parser.Stack(ctx, stack_name, tmpl, adopt_stack_data=data)
stack.store()
return stack
def test_boolean_type_provider(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {
'Foo': {'Type': 'Boolean'},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(object):
support_status = support.SupportStatus()
properties_schema = {"Foo":
properties.Schema(properties.Schema.BOOLEAN)}
attributes_schema = {}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(
{'HeatTemplateFormatVersion': '2012-12-12'},
files=files), env=env,
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource",
{"Foo": "False"})
temp_res = template_resource.TemplateResource('test_t_res',
definition, stack)
self.assertIsNone(temp_res.validate())
def test_system_template_retrieve_by_file(self):
# make sure that a TemplateResource defined in the global environment
# can be created and the template retrieved using the "file:"
# scheme.
g_env = resources.global_env()
test_templ_name = 'file:///etc/heatr/frodo.yaml'
g_env.load({'resource_registry':
{'Test::Frodo': test_templ_name}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template),
stack_id=str(uuid.uuid4()))
minimal_temp = json.dumps({'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {},
'Resources': {}})
self.m.StubOutWithMock(urlfetch, "get")
urlfetch.get(test_templ_name,
allowed_schemes=('http', 'https',
'file')).AndReturn(minimal_temp)
self.m.ReplayAll()
definition = rsrc_defn.ResourceDefinition('test_t_res',
'Test::Frodo')
temp_res = template_resource.TemplateResource('test_t_res',
definition,
stack)
self.assertIsNone(temp_res.validate())
self.m.VerifyAll()
def test_properties_extra_required(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {
'Blarg': {'Type': 'String'},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(object):
support_status = support.SupportStatus()
properties_schema = {}
attributes_schema = {}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template, files=files),
env=env,
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource",
{"Blarg": "wibble"})
temp_res = template_resource.TemplateResource('test_t_res',
definition, stack)
self.assertRaises(exception.StackValidationFailed,
temp_res.validate)
def test_properties_type_mismatch(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {
'Foo': {'Type': 'String'},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(object):
support_status = support.SupportStatus()
properties_schema = {"Foo":
properties.Schema(properties.Schema.MAP)}
attributes_schema = {}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(
{'HeatTemplateFormatVersion': '2012-12-12'},
files=files), env=env,
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource",
{"Foo": "bar"})
temp_res = template_resource.TemplateResource('test_t_res',
definition, stack)
ex = self.assertRaises(exception.StackValidationFailed,
temp_res.validate)
self.assertEqual("Property Foo type mismatch between facade "
"DummyResource (Map) and provider (String)",
six.text_type(ex))
def test_attributes_extra(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Outputs': {
'Foo': {'Value': 'bar'},
'Blarg': {'Value': 'wibble'},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(object):
support_status = support.SupportStatus()
properties_schema = {}
attributes_schema = {"Foo": attributes.Schema("A test attribute")}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template, files=files),
env=env,
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource")
temp_res = template_resource.TemplateResource('test_t_res',
definition, stack)
self.assertIsNone(temp_res.validate())
def test_properties_normal(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {
'Foo': {'Type': 'String'},
'Blarg': {'Type': 'String', 'Default': 'wibble'},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(object):
support_status = support.SupportStatus()
properties_schema = {"Foo":
properties.Schema(properties.Schema.STRING,
required=True)}
attributes_schema = {}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template, files=files),
env=env,
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource",
{"Foo": "bar"})
temp_res = template_resource.TemplateResource('test_t_res',
definition, stack)
self.assertIsNone(temp_res.validate())
def setUp(self):
super(VolumeTypeConstraintTest, self).setUp()
self.ctx = utils.dummy_context()
self.mock_get_volume_type = mock.Mock()
self.ctx.clients.client_plugin(
'cinder').get_volume_type = self.mock_get_volume_type
self.constraint = cinder.VolumeTypeConstraint()
def setUp(self):
super(TestMistralWorkflow, self).setUp()
resources.initialise()
utils.setup_dummy_db()
self.ctx = utils.dummy_context()
tmpl = template_format.parse(workflow_template)
self.stack = utils.parse_stack(tmpl, stack_name='test_stack')
resource_defns = self.stack.t.resource_definitions(self.stack)
self.rsrc_defn = resource_defns['workflow']
self.mistral = mock.Mock()
self.patchobject(workflow.Workflow, 'client',
return_value=self.mistral)
self.patches = []
self.patches.append(mock.patch.object(stack_user.StackUser,
'_create_user'))
self.patches.append(mock.patch.object(signal_responder.SignalResponder,
'_create_keypair'))
self.patches.append(mock.patch.object(client,
'mistral_base'))
self.patches.append(mock.patch.object(client.MistralClientPlugin,
'_create'))
for patch in self.patches:
patch.start()
self.client = client.MistralClientPlugin(self.ctx)
def setUp(self):
super(CinderClientPluginTest, self).setUp()
self.cinder_client = mock.MagicMock()
con = utils.dummy_context()
c = con.clients
self.cinder_plugin = c.client_plugin('cinder')
self.cinder_plugin.client = lambda: self.cinder_client
def setUp(self):
super(NovaClientPluginTestCase, self).setUp()
self.nova_client = mock.MagicMock()
con = utils.dummy_context()
c = con.clients
self.nova_plugin = c.client_plugin('nova')
self.nova_plugin._client = self.nova_client
def setUp(self):
super(ServerConstraintTest, self).setUp()
self.ctx = utils.dummy_context()
self.mock_get_server = mock.Mock()
self.ctx.clients.client_plugin(
'nova').get_server = self.mock_get_server
self.constraint = nova.ServerConstraint()
def setUp(self):
super(VolumeSnapshotConstraintTest, self).setUp()
self.ctx = utils.dummy_context()
self.mock_get_snapshot = mock.Mock()
self.ctx.clients.client_plugin(
'cinder').get_volume_snapshot = self.mock_get_snapshot
self.constraint = cinder.VolumeSnapshotConstraint()
def test_validate(self):
client = fakes_nova.FakeClient()
self.stub_keystoneclient()
self.patchobject(nova.NovaClientPlugin, '_create', return_value=client)
client.networks = mock.Mock()
network = collections.namedtuple("Network", ['id', 'label'])
network.id = '7f47ff06-0353-4013-b814-123b70b1b27d'
network.label = 'foo'
client.networks.get.return_value = network
constraint = nova.NetworkConstraint()
ctx = utils.dummy_context()
self.assertTrue(constraint.validate(network.id, ctx))
client.networks.get.side_effect = nova_exceptions.NotFound('')
client.networks.find.return_value = network
self.assertTrue(constraint.validate(network.id, ctx))
client.networks.find.side_effect = nova_exceptions.NotFound('')
self.assertFalse(constraint.validate(network.id, ctx))
client.networks.find.side_effect = nova_exceptions.NoUniqueMatch()
self.assertFalse(constraint.validate(network.id, ctx))
network.id = 'nonuuid'
client.networks.find.return_value = network
client.networks.find.side_effect = None
self.assertTrue(constraint.validate(network.id, ctx))
def _dummy_event(self, event_id):
resource = self.stack['generic1']
return Event(utils.dummy_context(), self.stack, 'CREATE', 'COMPLETE',
'state changed', 'z3455xyc-9f88-404d-a85b-5315293e67de',
resource.properties, resource.name, resource.type(),
uuid='abc123yc-9f88-404d-a85b-531529456xyz',
id=event_id)
def test_conv_empty_template_stack_update_delete(self, mock_cr):
stack = tools.get_stack('test_stack',
utils.dummy_context(),
template=tools.string_template_five,
convergence=True)
stack.store()
# create stack
stack.converge_stack(template=stack.t, action=stack.CREATE)
# update stack with new template
template2 = templatem.Template.create_empty_template(
version=stack.t.version)
curr_stack_db = stack_object.Stack.get_by_id(stack.context, stack.id)
curr_stack = parser.Stack.load(curr_stack_db._context,
stack=curr_stack_db)
# on our previous create_complete, worker would have updated the
# rsrc.requires. Mock the same behavior here.
self.stack = stack
with mock.patch.object(
parser.Stack,
'db_active_resources_get',
side_effect=self._mock_convg_db_update_requires):
curr_stack.thread_group_mgr = tools.DummyThreadGroupManager()
curr_stack.converge_stack(template=template2, action=stack.DELETE)
self.assertIsNotNone(curr_stack.ext_rsrcs_db)
deps = curr_stack.convergence_dependencies
self.assertEqual([((3, False), (1, False)), ((3, False), (2, False)),
((4, False), (3, False)), ((5, False), (3, False))],
sorted(deps._graph.edges()))
stack_db = stack_object.Stack.get_by_id(curr_stack.context,
curr_stack.id)
self.assertIsNotNone(stack_db.current_traversal)
self.assertIsNotNone(stack_db.prev_raw_template_id)
self.assertEqual(
sorted([[[3, False], [2, False]], [[3, False], [1, False]],
[[5, False], [3, False]], [[4, False], [3, False]]]),
sorted(stack_db.current_deps['edges']))
# check if sync_points are created for cleanup traversal
# [A, B, C, D, E, Stack]
for entity_id in [5, 4, 3, 2, 1, stack_db.id]:
is_update = False
if entity_id == stack_db.id:
is_update = True
sync_point = sync_point_object.SyncPoint.get_by_key(
stack_db._context, entity_id, stack_db.current_traversal,
is_update)
self.assertIsNotNone(sync_point, 'entity %s' % entity_id)
self.assertEqual(stack_db.id, sync_point.stack_id)
leaves = set(stack.convergence_dependencies.leaves())
expected_calls = []
for rsrc_id, is_update in sorted(leaves, key=lambda n: n.is_update):
expected_calls.append(
mock.call.worker_client.WorkerClient.check_resource(
stack.context, rsrc_id, stack.current_traversal,
{'input_data': {}}, is_update, None, False))
leaves = set(curr_stack.convergence_dependencies.leaves())
for rsrc_id, is_update in sorted(leaves, key=lambda n: n.is_update):
expected_calls.append(
mock.call.worker_client.WorkerClient.check_resource(
curr_stack.context, rsrc_id, curr_stack.current_traversal,
{'input_data': {}}, is_update, None, False))
self.assertEqual(expected_calls, mock_cr.mock_calls)
def setUp(self):
super(CRONExpressionConstraint, self).setUp()
self.ctx = utils.dummy_context()
self.constraint = cc.CRONExpressionConstraint()
def setUp(self):
super(TimezoneConstraintTest, self).setUp()
self.ctx = utils.dummy_context()
self.constraint = cc.TimezoneConstraint()
def setUp(self):
super(StackDeleteTest, self).setUp()
self.ctx = utils.dummy_context()
self.man = service.EngineService('a-host', 'a-topic')
self.man.create_periodic_tasks()
def get_stack(self, stack_id):
ctx = utils.dummy_context(tenant_id='test_tenant')
stack = parser.Stack.load(ctx, stack_id)
self.stack_id = stack_id
return stack
def rollback_stack(self, stack_name):
cntxt = utils.dummy_context()
db_stack = db_api.stack_get_by_name(cntxt, stack_name)
stk = stack.Stack.load(cntxt, stack=db_stack)
stk.rollback()
def test_stack_create_no_credentials(self):
cfg.CONF.set_default('deferred_auth_method', 'password')
stack_name = 'test_stack_create_no_credentials'
params = {'foo': 'bar'}
template = '{ "Template": "data" }'
stk = tools.get_stack(stack_name, self.ctx)
# force check for credentials on create
stk['WebServer'].requires_deferred_auth = True
mock_tmpl = self.patchobject(templatem, 'Template', return_value=stk.t)
mock_env = self.patchobject(environment,
'Environment',
return_value=stk.env)
mock_stack = self.patchobject(stack, 'Stack', return_value=stk)
# test stack create using context without password
ctx_no_pwd = utils.dummy_context(password=None)
ex = self.assertRaises(dispatcher.ExpectedException,
self.man.create_stack, ctx_no_pwd, stack_name,
template, params, None, {}, None)
self.assertEqual(exception.MissingCredentialError, ex.exc_info[0])
self.assertEqual('Missing required credential: X-Auth-Key',
six.text_type(ex.exc_info[1]))
mock_tmpl.assert_called_once_with(template, files=None, env=stk.env)
mock_env.assert_called_once_with(params)
mock_stack.assert_called_once_with(ctx_no_pwd,
stack_name,
stk.t,
owner_id=None,
nested_depth=0,
user_creds_id=None,
stack_user_project_id=None,
convergence=False,
parent_resource=None)
mock_tmpl.reset_mock()
mock_env.reset_mock()
mock_stack.reset_mock()
# test stack create using context without user
ctx_no_pwd = utils.dummy_context(password=None)
ctx_no_user = utils.dummy_context(user=None)
ex = self.assertRaises(dispatcher.ExpectedException,
self.man.create_stack, ctx_no_user, stack_name,
template, params, None, {})
self.assertEqual(exception.MissingCredentialError, ex.exc_info[0])
self.assertEqual('Missing required credential: X-Auth-User',
six.text_type(ex.exc_info[1]))
mock_tmpl.assert_called_once_with(template, files=None, env=stk.env)
mock_env.assert_called_once_with(params)
mock_stack.assert_called_once_with(ctx_no_user,
stack_name,
stk.t,
owner_id=None,
nested_depth=0,
user_creds_id=None,
stack_user_project_id=None,
convergence=False,
parent_resource=None)
def setUp(self):
super(SoftwareDeploymentTest, self).setUp()
self.ctx = utils.dummy_context()
def _create_test_instance_with_nic(self, return_server, name):
stack_name = '%s_s' % name
t = template_format.parse(wp_template_with_nic)
kwargs = {
'KeyName': 'test',
'InstanceType': 'm1.large',
'SubnetId': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861'
}
tmpl = template.Template(t, env=environment.Environment(kwargs))
self.stack = parser.Stack(utils.dummy_context(),
stack_name,
tmpl,
stack_id=str(uuid.uuid4()))
image_id = 'CentOS 5.2'
t['Resources']['WebServer']['Properties']['ImageId'] = image_id
resource_defns = self.stack.t.resource_definitions(self.stack)
nic = net_interfaces.NetworkInterface('%s_nic' % name,
resource_defns['nic1'],
self.stack)
instance = instances.Instance('%s_name' % name,
resource_defns['WebServer'], self.stack)
metadata = instance.metadata_get()
self._mock_get_image_id_success(image_id, 1)
self.stub_SubnetConstraint_validate()
self.patchobject(nic, 'client', return_value=FakeNeutron())
self.patchobject(neutron.NeutronClientPlugin,
'_create',
return_value=FakeNeutron())
self.patchobject(nova.NovaClientPlugin, 'client', return_value=self.fc)
# need to resolve the template functions
server_userdata = instance.client_plugin().build_userdata(
metadata, instance.properties['UserData'], 'ec2-user')
self.patchobject(nova.NovaClientPlugin,
'build_userdata',
return_value=server_userdata)
self.patchobject(self.fc.servers, 'create', return_value=return_server)
# create network interface
scheduler.TaskRunner(nic.create)()
self.stack.resources["nic1"] = nic
scheduler.TaskRunner(instance.create)()
self.fc.servers.create.assert_called_once_with(
image=1,
flavor=3,
key_name='test',
name=utils.PhysName(stack_name, instance.name),
security_groups=None,
userdata=server_userdata,
scheduler_hints=None,
meta=None,
nics=[{
'port-id': '64d913c1-bcb1-42d2-8f0a-9593dbcaf251'
}],
availability_zone=None,
block_device_mapping=None)
self.m_f_i.assert_called_with(image_id)
nova.NovaClientPlugin.build_userdata.assert_called_once_with(
metadata, instance.properties['UserData'], 'ec2-user')
neutron.NeutronClientPlugin._create.assert_called_once_with()
nova.NovaClientPlugin.client.assert_called_with()
glance.GlanceClientPlugin.find_image_by_name_or_id.assert_called_with(
image_id)
return instance
def parse_stack(self, templ_obj):
stack_name = 'test_value_stack'
stack = parser.Stack(utils.dummy_context(), stack_name, templ_obj)
stack.validate()
stack.store()
return stack
def setUp(self):
super(MultipartMimeTest, self).setUp()
self.ctx = utils.dummy_context()
self.init_config()
def setUp(self):
super(ZaqarSubscriptionTest, self).setUp()
self.fc = self.m.CreateMockAnything()
self.ctx = utils.dummy_context()
def setUp(self):
super(ProviderTemplateAdoptTest, self).setUp()
self.ctx = utils.dummy_context('test_username', 'aaaa', 'password')
def parse_stack(self, t):
stack_name = 'test_stack'
tmpl = parser.Template(t)
stack = parser.Stack(utils.dummy_context(), stack_name, tmpl)
stack.store()
return stack
def setUp(self):
super(DepAttrsTest, self).setUp()
self.ctx = utils.dummy_context()
def test_to_parameters(self):
"""Tests property conversion to parameter values."""
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {
'Foo': {'Type': 'String'},
'AList': {'Type': 'CommaDelimitedList'},
'ListEmpty': {'Type': 'CommaDelimitedList'},
'ANum': {'Type': 'Number'},
'AMap': {'Type': 'Json'},
},
'Outputs': {
'Foo': {'Value': 'bar'},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(object):
support_status = support.SupportStatus()
attributes_schema = {"Foo": attributes.Schema("A test attribute")}
properties_schema = {
"Foo": {"Type": "String"},
"AList": {"Type": "List"},
"ListEmpty": {"Type": "List"},
"ANum": {"Type": "Number"},
"AMap": {"Type": "Map"}
}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template, files=files),
env=env,
stack_id=str(uuid.uuid4()))
map_prop_val = {
"key1": "val1",
"key2": ["lval1", "lval2", "lval3"],
"key3": {
"key4": 4,
"key5": False
}
}
prop_vals = {
"Foo": "Bar",
"AList": ["one", "two", "three"],
"ListEmpty": [],
"ANum": 5,
"AMap": map_prop_val,
}
definition = rsrc_defn.ResourceDefinition('test_t_res',
'DummyResource',
prop_vals)
temp_res = template_resource.TemplateResource('test_t_res',
definition, stack)
temp_res.validate()
converted_params = temp_res.child_params()
self.assertTrue(converted_params)
for key in DummyResource.properties_schema:
self.assertIn(key, converted_params)
# verify String conversion
self.assertEqual("Bar", converted_params.get("Foo"))
# verify List conversion
self.assertEqual("one,two,three", converted_params.get("AList"))
# verify Number conversion
self.assertEqual(5, converted_params.get("ANum"))
# verify Map conversion
self.assertEqual(map_prop_val, converted_params.get("AMap"))
with mock.patch.object(properties.Properties, '__getitem__') as m_get:
m_get.side_effect = ValueError('boom')
# If the property doesn't exist on INIT, return default value
temp_res.action = temp_res.INIT
converted_params = temp_res.child_params()
for key in DummyResource.properties_schema:
self.assertIn(key, converted_params)
self.assertEqual({}, converted_params['AMap'])
self.assertEqual(0, converted_params['ANum'])
# If the property doesn't exist past INIT, then error out
temp_res.action = temp_res.CREATE
self.assertRaises(ValueError, temp_res.child_params)
def test_wait_metadata(self, mock_identifier, mock_sleep, mock_available,
mock_check, mock_handle, *args):
"""Tests a wait condition metadata update after a signal call."""
mock_available.return_value = (True, None)
# Setup Stack
temp = template_format.parse(TEST_TEMPLATE_WAIT_CONDITION)
template = tmpl.Template(temp)
ctx = utils.dummy_context()
stack = stk.Stack(ctx, 'test-stack', template, disable_rollback=True)
stack.store()
self.stub_KeypairConstraint_validate()
res_id = identifier.ResourceIdentifier('test_tenant_id', stack.name,
stack.id, '', 'WH')
mock_identifier.return_value = res_id
watch = stack['WC']
inst = stack['S2']
# Setup Sleep Behavior
self.run_empty = True
def check_empty(sleep_time):
self.assertEqual('{}', watch.FnGetAtt('Data'))
self.assertIsNone(inst.metadata_get()['test'])
def update_metadata(unique_id, data, reason):
self.man.resource_signal(ctx,
dict(stack.identifier()),
'WH', {
'Data': data,
'Reason': reason,
'Status': 'SUCCESS',
'UniqueId': unique_id
},
sync_call=True)
def post_success(sleep_time):
update_metadata('123', 'foo', 'bar')
def side_effect_popper(sleep_time):
wh = stack['WH']
if wh.status == wh.IN_PROGRESS:
return
elif self.run_empty:
self.run_empty = False
check_empty(sleep_time)
else:
post_success(sleep_time)
mock_sleep.side_effect = side_effect_popper
# Test Initial Creation
stack.create()
self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state)
self.assertEqual('{"123": "foo"}', watch.FnGetAtt('Data'))
self.assertEqual('{"123": "foo"}', inst.metadata_get()['test'])
# Test Update
update_metadata('456', 'blarg', 'wibble')
self.assertEqual({
'123': 'foo',
'456': 'blarg'
}, jsonutils.loads(watch.FnGetAtt('Data')))
self.assertEqual('{"123": "foo"}', inst.metadata_get()['test'])
self.assertEqual({
'123': 'foo',
'456': 'blarg'
}, jsonutils.loads(inst.metadata_get(refresh=True)['test']))
# Verify outgoing calls
self.assertGreater(mock_available.call_count, 0)
self.assertEqual(2, mock_handle.call_count)
self.assertEqual(2, mock_check.call_count)
def test_get_attribute_autoscaling(self):
t = template_format.parse(heat_autoscaling_group_template)
tmpl = templatem.Template(t)
stack = parser.Stack(utils.dummy_context(), 'test_att', tmpl)
rsrc = stack['my_autoscaling_group']
self.assertEqual(0, rsrc.FnGetAtt(rsrc.CURRENT_SIZE))
def _create_test_instance_with_nic(self, return_server, name):
stack_name = '%s_s' % name
t = template_format.parse(wp_template_with_nic)
template = parser.Template(t)
kwargs = {
'KeyName': 'test',
'InstanceType': 'm1.large',
'SubnetId': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861'
}
stack = parser.Stack(utils.dummy_context(),
stack_name,
template,
environment.Environment(kwargs),
stack_id=str(uuid.uuid4()))
t['Resources']['WebServer']['Properties']['ImageId'] = 'CentOS 5.2'
nic = network_interfaces.NetworkInterface('%s_nic' % name,
t['Resources']['nic1'],
stack)
instance = instances.Instance('%s_name' % name,
t['Resources']['WebServer'], stack)
self.m.StubOutWithMock(nic, 'neutron')
nic.neutron().MultipleTimes().AndReturn(FakeNeutron())
self.m.StubOutWithMock(instance, 'nova')
instance.nova().MultipleTimes().AndReturn(self.fc)
self.m.StubOutWithMock(clients.OpenStackClients, 'nova')
clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc)
# need to resolve the template functions
server_userdata = nova_utils.build_userdata(
instance, instance.t['Properties']['UserData'], 'ec2-user')
self.m.StubOutWithMock(nova_utils, 'build_userdata')
nova_utils.build_userdata(instance,
instance.t['Properties']['UserData'],
'ec2-user').AndReturn(server_userdata)
self.m.StubOutWithMock(self.fc.servers, 'create')
self.fc.servers.create(image=1,
flavor=3,
key_name='test',
name=utils.PhysName(stack_name, instance.name),
security_groups=None,
userdata=server_userdata,
scheduler_hints=None,
meta=None,
nics=[{
'port-id':
'64d913c1-bcb1-42d2-8f0a-9593dbcaf251'
}],
availability_zone=None).AndReturn(return_server)
self.m.ReplayAll()
# create network interface
scheduler.TaskRunner(nic.create)()
stack["nic1"] = nic
scheduler.TaskRunner(instance.create)()
return instance
def setUp(self):
super(ManilaShareTypeTest, self).setUp()
resources.initialise()
utils.setup_dummy_db()
self.ctx = utils.dummy_context()
def setUp(self):
super(HeatTestCase, self).setUp()
self.ctx = utils.dummy_context()
def setUp(self):
super(TemplateTest, self).setUp()
self.ctx = utils.dummy_context()
def test_cinder_api_v2_only(self):
self.stub_auth(only_services=['volumev2'])
ctx = utils.dummy_context()
client = clients.Clients(ctx).client('cinder')
self.assertEqual(2, client.volume_api_version)
def setUp(self):
super(TestRandomString, self).setUp()
self.ctx = utils.dummy_context()
def setUp(self):
super(ExpirationConstraintTest, self).setUp()
self.ctx = utils.dummy_context()
self.constraint = cc.ExpirationConstraint()
def test_cinder_api_v1_and_v2(self):
self.stub_auth()
ctx = utils.dummy_context()
client = clients.Clients(ctx).client('cinder')
self.assertEqual(2, client.volume_api_version)
def setUp(self):
super(FIPDNSNameConstraintTest, self).setUp()
self.ctx = utils.dummy_context()
self.constraint = cc.RelativeDNSNameConstraint()
def setUp(self):
super(DNSDomainConstraintTest, self).setUp()
self.ctx = utils.dummy_context()
self.constraint = cc.DNSDomainConstraint()
def setUp(self):
super(StackServiceWatcherTest, self).setUp()
self.ctx = utils.dummy_context(tenant_id='stack_service_test_tenant')
def setUp(self):
super(ZaqarMessageQueueTest, self).setUp()
self.fc = self.m.CreateMockAnything()
self.ctx = utils.dummy_context()
