openstack/deb-heat
Code Issues Proposed changes

Merge "Pass the environment into the Template class and not Stack"

Browse Source
This commit is contained in:
Jenkins 2015-03-18 03:28:34 +00:00 committed by Gerrit Code Review
commit ead3f0acf2
25 changed files with 194 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
contrib/rackspace/rackspace/tests/test_rackspace_cloud_server.py
View File

@ -90,9 +90,10 @@ class CloudServersTest(common.HeatTestCase):
def _setup_test_stack(self, stack_name):
t = template_format.parse(wp_template)
templ = template.Template(t)
templ = template.Template(
t, env=environment.Environment({'key_name': 'test'}))
stack = parser.Stack(self.ctx, stack_name, templ,
environment.Environment({'key_name': 'test'}),
stack_id=uuidutils.generate_uuid())
return (templ, stack)

4
contrib/rackspace/rackspace/tests/test_rackspace_dns.py
View File

@ -101,11 +101,11 @@ class RackspaceDnsTest(common.HeatTestCase):
def _setup_test_cloud_dns_instance(self, name, parsed_t):
stack_name = '%s_stack' % name
t = parsed_t
templ = template.Template(t)
templ = template.Template(
t, env=environment.Environment({'name': 'test'}))
stack = parser.Stack(utils.dummy_context(),
stack_name,
templ,
environment.Environment({'name': 'test'}),
stack_id=str(uuid.uuid4()))
instance = cloud_dns.CloudDns(

8
heat/engine/resources/openstack/heat/instance_group.py
View File

@ -16,6 +16,7 @@ from heat.common import grouputils
from heat.common.i18n import _
from heat.common import timeutils as iso8601utils
from heat.engine import attributes
from heat.engine import environment
from heat.engine import function
from heat.engine import properties
from heat.engine.resources import stack_resource
@ -264,7 +265,12 @@ class InstanceGroup(stack_resource.StackResource):
definitions = template.resource_templates(
old_resources, instance_definition, num_instances, num_replace)
return template.make_template(definitions, version=template_version)
child_env = environment.get_child_environment(
self.stack.env,
self.child_params(), item_to_remove=self.resource_info)
return template.make_template(definitions, version=template_version,
child_env=child_env)
def _try_rolling_update(self, prop_diff):
if (self.update_policy[self.ROLLING_UPDATE] and

30
heat/engine/stack.py
View File

@ -73,7 +73,7 @@ class Stack(collections.Mapping):
_zones = None
def __init__(self, context, stack_name, tmpl, env=None,
def __init__(self, context, stack_name, tmpl,
stack_id=None, action=None, status=None,
status_reason='', timeout_mins=None, resolve_data=True,
disable_rollback=True, parent_resource=None, owner_id=None,
@ -138,7 +138,6 @@ class Stack(collections.Mapping):
resources.initialise()
self.env = env or self.t.env
self.parameters = self.t.parameters(
self.identifier(),
user_params=self.env.params,
@ -150,6 +149,11 @@ class Stack(collections.Mapping):
else:
self.outputs = {}
@property
def env(self):
"""This is a helper to allow resources to access stack.env."""
return self.t.env
@property
def parent_resource(self):
"""Dynamically load up the parent_resource.
@ -327,10 +331,15 @@ class Stack(collections.Mapping):
use_stored_context=False):
template = tmpl.Template.load(
context, stack.raw_template_id, stack.raw_template)
return cls(context, stack.name, template, template.env,
stack.id, stack.action, stack.status, stack.status_reason,
stack.timeout, resolve_data, stack.disable_rollback,
parent_resource, owner_id=stack.owner_id,
return cls(context, stack.name, template,
stack_id=stack.id,
action=stack.action, status=stack.status,
status_reason=stack.status_reason,
timeout_mins=stack.timeout,
resolve_data=resolve_data,
disable_rollback=stack.disable_rollback,
parent_resource=parent_resource,
owner_id=stack.owner_id,
stack_user_project_id=stack.stack_user_project_id,
created_time=stack.created_at,
updated_time=stack.updated_at,
@ -729,7 +738,7 @@ class Stack(collections.Mapping):
return self.load(self.context, stack=s)
elif create_if_missing:
prev = type(self)(self.context, self.name, copy.deepcopy(self.t),
self.env, owner_id=self.id,
owner_id=self.id,
user_creds_id=self.user_creds_id,
convergence=self.convergence)
prev.store(backup=True)
@ -806,7 +815,7 @@ class Stack(collections.Mapping):
# Oldstack is useless when the action is not UPDATE , so we don't
# need to build it, this can avoid some unexpected errors.
oldstack = Stack(self.context, self.name, copy.deepcopy(self.t),
self.env, convergence=self.convergence)
convergence=self.convergence)
backup_stack = self._backup_stack()
try:
update_task = update.StackUpdate(
@ -815,7 +824,6 @@ class Stack(collections.Mapping):
error_wait_time=cfg.CONF.error_wait_time)
updater = scheduler.TaskRunner(update_task)
self.env = newstack.env
self.parameters = newstack.parameters
self.t.files = newstack.t.files
self.t.env = newstack.t.env
@ -1152,7 +1160,7 @@ class Stack(collections.Mapping):
return
self.updated_time = datetime.datetime.utcnow()
template = tmpl.Template(snapshot.data['template'])
template = tmpl.Template(snapshot.data['template'], env=self.env)
for name, defn in six.iteritems(template.resource_definitions(self)):
rsrc = resource.Resource(name, defn, self)
@ -1162,7 +1170,7 @@ class Stack(collections.Mapping):
defn = handle_restore(defn, data)
template.add_resource(defn, name)
newstack = self.__class__(self.context, self.name, template, self.env,
newstack = self.__class__(self.context, self.name, template,
timeout_mins=self.timeout_mins,
disable_rollback=self.disable_rollback)
newstack.parameters.set_stack_id(self.identifier())

3
heat/engine/template.py
View File

@ -119,7 +119,8 @@ class Template(collections.Mapping):
self.version = get_version(self.t, _template_classes.keys())
def __deepcopy__(self, memo):
return Template(copy.deepcopy(self.t, memo), files=self.files)
return Template(copy.deepcopy(self.t, memo), files=self.files,
env=self.env)
@classmethod
def load(cls, context, template_id, t=None):

5
heat/scaling/template.py
View File

@ -40,7 +40,8 @@ def resource_templates(old_resources, resource_definition,
def make_template(resource_definitions,
version=('heat_template_version', '2013-05-23')):
version=('heat_template_version', '2013-05-23'),
child_env=None):
"""
Return a Template object containing the given resource definitions.
@ -48,7 +49,7 @@ def make_template(resource_definitions,
can be specified by passing a (version_type, version_string) tuple matching
any of the available template format plugins.
"""
tmpl = template.Template(dict([version]))
tmpl = template.Template(dict([version]), env=child_env)
for name, defn in resource_definitions:
tmpl.add_resource(defn, name)

5
heat/tests/aws/test_waitcondition.py
View File

@ -87,10 +87,10 @@ class WaitConditionTest(common.HeatTestCase):
stub=True, stub_status=True):
params = params or {}
temp = template_format.parse(template)
template = parser.Template(temp)
template = parser.Template(temp,
env=environment.Environment(params))
ctx = utils.dummy_context(tenant_id='test_tenant')
stack = parser.Stack(ctx, 'test_stack', template,
environment.Environment(params),
disable_rollback=True)
# Stub out the stack ID so we have a known value
@ -533,7 +533,6 @@ class WaitConditionUpdateTest(common.HeatTestCase):
template = parser.Template(temp)
ctx = utils.dummy_context(tenant_id='test_tenant')
stack = parser.Stack(ctx, 'test_stack', template,
environment.Environment({}),
disable_rollback=True)
stack_id = str(uuid.uuid4())

4
heat/tests/openstack/test_waitcondition.py
View File

@ -80,10 +80,10 @@ class HeatWaitConditionTest(common.HeatTestCase):
params={},
stub=True, stub_status=True):
temp = template_format.parse(template)
template = parser.Template(temp)
template = parser.Template(temp,
env=environment.Environment(params))
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

10
heat/tests/test_engine_service.py
View File

@ -734,8 +734,7 @@ class StackServiceCreateUpdateDeleteTest(common.HeatTestCase):
'C': {'Type': 'GenericResourceType'}}}
template = templatem.Template(tpl)
stack = parser.Stack(self.ctx, stack_name, template,
environment.Environment({}))
stack = parser.Stack(self.ctx, stack_name, template)
self.m.StubOutWithMock(templatem, 'Template')
self.m.StubOutWithMock(environment, 'Environment')
@ -1059,10 +1058,10 @@ class StackServiceCreateUpdateDeleteTest(common.HeatTestCase):
s = stack_object.Stack.get_by_id(self.ctx, sid)
t = template_format.parse(wp_template_no_default)
template = templatem.Template(t)
env = environment.Environment({'parameters': with_params,
'resource_registry': {'rsc': 'test'}})
stack = parser.Stack(self.ctx, stack_name, template, env)
template = templatem.Template(t, env=env)
stack = parser.Stack(self.ctx, stack_name, template)
self._stub_update_mocks(s, old_stack)
@ -3003,8 +3002,7 @@ class StackServiceTest(common.HeatTestCase):
}
}
templ = templatem.Template(lazy_load_template)
stack = parser.Stack(self.ctx, stack_name, templ,
environment.Environment({}))
stack = parser.Stack(self.ctx, stack_name, templ)
self.assertIsNone(stack._resources)
self.assertIsNone(stack._dependencies)

5
heat/tests/test_function.py
View File

@ -177,8 +177,9 @@ class ValidateGetAttTest(common.HeatTestCase):
self.stack = parser.Stack(
utils.dummy_context(), 'test_stack',
parser.Template({"HeatTemplateFormatVersion": "2012-12-12"}),
env=env, stack_id=str(uuid.uuid4()))
parser.Template({"HeatTemplateFormatVersion": "2012-12-12"},
env=env),
stack_id=str(uuid.uuid4()))
res_defn = rsrc_defn.ResourceDefinition('test_rsrc',
'OS::Test::GenericResource')
self.rsrc = resource.Resource('test_rsrc', res_defn, self.stack)

14
heat/tests/test_hot.py
View File

@ -1053,16 +1053,18 @@ class HotStackTest(common.HeatTestCase):
'update_template_diff')
self.stack = parser.Stack(self.ctx, 'update_test_stack',
template.Template(tmpl),
environment.Environment({'foo': 'abc'}))
template.Template(
tmpl, env=environment.Environment(
{'foo': 'abc'})))
self.stack.store()
self.stack.create()
self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE),
self.stack.state)
updated_stack = parser.Stack(self.ctx, 'updated_stack',
template.Template(tmpl),
environment.Environment({'foo': 'xyz'}))
template.Template(
tmpl, env=environment.Environment(
{'foo': 'xyz'})))
def check_props(*args):
self.assertEqual('abc', self.stack['AResource'].properties['Foo'])
@ -1307,9 +1309,9 @@ class StackParametersTest(common.HeatTestCase):
def test_param_refs(self):
"""Test if parameter references work."""
tmpl = parser.Template(self.props_template)
env = environment.Environment(self.params)
stack = parser.Stack(utils.dummy_context(), 'test', tmpl, env,
tmpl = parser.Template(self.props_template, env=env)
stack = parser.Stack(utils.dummy_context(), 'test', tmpl,
stack_id='1ba8c334-2297-4312-8c7c-43763a988ced',
tenant_id='9913ef0a-b8be-4b33-b574-9061441bd373')
self.assertEqual(self.expected,

4
heat/tests/test_instance.py
View File

@ -79,9 +79,9 @@ class InstancesTest(common.HeatTestCase):
def _setup_test_stack(self, stack_name):
t = template_format.parse(wp_template)
template = parser.Template(t)
template = parser.Template(
t, env=environment.Environment({'KeyName': 'test'}))
stack = parser.Stack(utils.dummy_context(), stack_name, template,
environment.Environment({'KeyName': 'test'}),
stack_id=str(uuid.uuid4()))
return (template, stack)

8
heat/tests/test_instance_network.py
View File

@ -198,12 +198,12 @@ class instancesTest(common.HeatTestCase):
def _create_test_instance(self, return_server, name):
stack_name = '%s_s' % name
t = template_format.parse(wp_template)
template = parser.Template(t)
kwargs = {'KeyName': 'test',
'InstanceType': 'm1.large',
'SubnetId': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861'}
template = parser.Template(t,
env=environment.Environment(kwargs))
stack = parser.Stack(utils.dummy_context(), stack_name, template,
environment.Environment(kwargs),
stack_id=str(uuid.uuid4()))
image_id = 'CentOS 5.2'
t['Resources']['WebServer']['Properties']['ImageId'] = image_id
@ -253,12 +253,12 @@ class instancesTest(common.HeatTestCase):
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'}
template = parser.Template(t,
env=environment.Environment(kwargs))
stack = parser.Stack(utils.dummy_context(), stack_name, template,
environment.Environment(kwargs),
stack_id=str(uuid.uuid4()))
image_id = 'CentOS 5.2'
t['Resources']['WebServer']['Properties']['ImageId'] = image_id

8
heat/tests/test_metadata_refresh.py
View File

@ -154,10 +154,10 @@ class MetadataRefreshTest(common.HeatTestCase):
def create_stack(self, stack_name='test_stack', params=None):
params = params or {}
temp = template_format.parse(test_template_metadata)
template = parser.Template(temp)
template = parser.Template(temp,
env=environment.Environment(params))
ctx = utils.dummy_context()
stack = parser.Stack(ctx, stack_name, template,
environment.Environment(params),
disable_rollback=True)
self.stack_id = stack.store()
@ -314,10 +314,10 @@ class MetadataRefreshTestServer(common.HeatTestCase):
def create_stack(self, stack_name='test_stack_native', params=None):
params = params or {}
temp = template_format.parse(test_template_server)
template = parser.Template(temp)
template = parser.Template(temp,
env=environment.Environment(params))
ctx = utils.dummy_context()
stack = parser.Stack(ctx, stack_name, template,
environment.Environment(params),
disable_rollback=True)
self.stack_id = stack.store()

48
heat/tests/test_provider_template.py
View File

@ -127,8 +127,8 @@ class ProviderTemplateTest(common.HeatTestCase):
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template, files=files),
env=env,
parser.Template(empty_template, files=files,
env=env),
stack_id=str(uuid.uuid4()))
map_prop_val = {
@ -208,8 +208,8 @@ class ProviderTemplateTest(common.HeatTestCase):
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template, files=files),
env=env,
parser.Template(empty_template, files=files,
env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
@ -237,8 +237,8 @@ class ProviderTemplateTest(common.HeatTestCase):
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template, files=files),
env=env,
parser.Template(empty_template, files=files,
env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
@ -270,8 +270,8 @@ class ProviderTemplateTest(common.HeatTestCase):
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template, files=files),
env=env,
parser.Template(empty_template, files=files,
env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
@ -302,8 +302,8 @@ class ProviderTemplateTest(common.HeatTestCase):
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template, files=files),
env=env,
parser.Template(empty_template, files=files,
env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
@ -332,8 +332,8 @@ class ProviderTemplateTest(common.HeatTestCase):
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template, files=files),
env=env,
parser.Template(empty_template, files=files,
env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
@ -366,7 +366,7 @@ class ProviderTemplateTest(common.HeatTestCase):
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(
{'HeatTemplateFormatVersion': '2012-12-12'},
files=files), env=env,
files=files, env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
@ -402,7 +402,7 @@ class ProviderTemplateTest(common.HeatTestCase):
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(
{'HeatTemplateFormatVersion': '2012-12-12'},
files=files), env=env,
files=files, env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
@ -434,7 +434,7 @@ class ProviderTemplateTest(common.HeatTestCase):
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(
{'HeatTemplateFormatVersion': '2012-12-12'},
files=files), env=env,
files=files, env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
@ -468,7 +468,7 @@ class ProviderTemplateTest(common.HeatTestCase):
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(
{'HeatTemplateFormatVersion': '2012-12-12'},
files=files), env=env,
files=files, env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
@ -503,7 +503,7 @@ class ProviderTemplateTest(common.HeatTestCase):
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(
{'HeatTemplateFormatVersion': '2012-12-12'},
files=files), env=env,
files=files, env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('foo',
@ -547,7 +547,7 @@ class ProviderTemplateTest(common.HeatTestCase):
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(
{'HeatTemplateFormatVersion': '2012-12-12'},
files=files), env=env,
files=files, env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
@ -686,7 +686,7 @@ class ProviderTemplateTest(common.HeatTestCase):
env.load({'resource_registry':
{'Test::Flippy': test_templ_name}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template), env=env,
parser.Template(empty_template, env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
@ -738,7 +738,7 @@ class ProviderTemplateTest(common.HeatTestCase):
env.load({'resource_registry':
{'Test::Flippy': test_templ_name}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template), env=env,
parser.Template(empty_template, env=env),
stack_id=str(uuid.uuid4()))
self.m.StubOutWithMock(urlfetch, "get")
@ -767,7 +767,7 @@ class ProviderTemplateTest(common.HeatTestCase):
env.load({'resource_registry':
{'Test::Flippy': test_templ_name}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template), env=env,
parser.Template(empty_template, env=env),
stack_id=str(uuid.uuid4()))
self.m.ReplayAll()
@ -790,7 +790,7 @@ class ProviderTemplateTest(common.HeatTestCase):
env.load({'resource_registry':
{'Test::Tmpl': test_templ_name}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template), env=env,
parser.Template(empty_template, env=env),
stack_id=str(uuid.uuid4()))
self.m.StubOutWithMock(urlfetch, "get")
@ -836,8 +836,8 @@ class TemplateResourceCrudTest(common.HeatTestCase):
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template, files=files),
env=env,
parser.Template(empty_template, files=files,
env=env),
stack_id=str(uuid.uuid4()))
self.defn = rsrc_defn.ResourceDefinition('test_t_res',

11
heat/tests/test_resource.py
View File

@ -62,8 +62,9 @@ class ResourceTest(common.HeatTestCase):
u'ResourceWithCustomConstraint'}})
self.stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template),
env=self.env, stack_id=str(uuid.uuid4()))
parser.Template(empty_template,
env=self.env),
stack_id=str(uuid.uuid4()))
self.patch('heat.engine.resource.warnings')
def test_get_class_ok(self):
@ -1083,7 +1084,7 @@ class ResourceTest(common.HeatTestCase):
self.assertFalse(res.is_using_neutron())
def _test_skip_validation_if_custom_constraint(self, tmpl):
stack = parser.Stack(utils.dummy_context(), 'test', tmpl, env=self.env)
stack = parser.Stack(utils.dummy_context(), 'test', tmpl)
stack.store()
path = ('heat.engine.clients.os.neutron.NetworkConstraint.'
'validate_with_client')
@ -1104,7 +1105,7 @@ class ResourceTest(common.HeatTestCase):
}
}
}
})
}, env=self.env)
self._test_skip_validation_if_custom_constraint(tmpl)
def test_hot_ref_skip_validation_if_custom_constraint(self):
@ -1119,7 +1120,7 @@ class ResourceTest(common.HeatTestCase):
}
}
}
})
}, env=self.env)
self._test_skip_validation_if_custom_constraint(tmpl)

5
heat/tests/test_server.py
View File

@ -119,9 +119,10 @@ class ServersTest(common.HeatTestCase):
def _setup_test_stack(self, stack_name, test_templ=wp_template):
t = template_format.parse(test_templ)
templ = template.Template(t)
templ = template.Template(t,
env=environment.Environment(
{'key_name': 'test'}))
stack = parser.Stack(utils.dummy_context(), stack_name, templ,
environment.Environment({'key_name': 'test'}),
stack_id=uuidutils.generate_uuid(),
stack_user_project_id='8888')
return (templ, stack)

5
heat/tests/test_server_tags.py
View File

@ -65,9 +65,10 @@ class ServerTagsTest(common.HeatTestCase):
def _setup_test_instance(self, intags=None, nova_tags=None):
stack_name = 'tag_test'
t = template_format.parse(instance_template)
template = parser.Template(t)
template = parser.Template(t,
env=environment.Environment(
{'KeyName': 'test'}))
stack = parser.Stack(utils.dummy_context(), stack_name, template,
environment.Environment({'KeyName': 'test'}),
stack_id=str(uuid.uuid4()))
t['Resources']['WebServer']['Properties']['Tags'] = intags

4
heat/tests/test_sqlalchemy_api.py
View File

@ -100,10 +100,10 @@ class SqlAlchemyTest(common.HeatTestCase):
def _setup_test_stack(self, stack_name, stack_id=None, owner_id=None,
stack_user_project_id=None, backup=False):
t = template_format.parse(wp_template)
template = parser.Template(t)
template = parser.Template(
t, env=environment.Environment({'KeyName': 'test'}))
stack_id = stack_id or str(uuid.uuid4())
stack = parser.Stack(self.ctx, stack_name, template,
environment.Environment({'KeyName': 'test'}),
owner_id=owner_id,
stack_user_project_id=stack_user_project_id)
with utils.UUIDStub(stack_id):

24
heat/tests/test_stack.py
View File

@ -276,10 +276,12 @@ class StackTest(common.HeatTestCase):
).AndReturn(t)
self.m.StubOutWithMock(stack.Stack, '__init__')
stack.Stack.__init__(self.ctx, stk.name, t, t.env, stk.id,
stk.action, stk.status, stk.status_reason,
stk.timeout, True, stk.disable_rollback,
'parent', owner_id=None,
stack.Stack.__init__(self.ctx, stk.name, t, stack_id=stk.id,
action=stk.action, status=stk.status,
status_reason=stk.status_reason,
timeout_mins=stk.timeout, resolve_data=True,
disable_rollback=stk.disable_rollback,
parent_resource='parent', owner_id=None,
stack_user_project_id=None,
created_time=mox.IgnoreArg(),
updated_time=None,
@ -319,10 +321,9 @@ class StackTest(common.HeatTestCase):
"metadata": {}}}'''
env = environment.Environment({'parameters': {'param1': 'test'}})
self.stack = stack.Stack(self.ctx, 'stack_details_test',
template.Template(tpl),
template.Template(tpl, env=env),
tenant_id='123',
stack_user_project_id='234',
env=env)
stack_user_project_id='234')
self.stack.store()
info = self.stack.prepare_abandon()
self.assertEqual('CREATE', info['action'])
@ -1459,9 +1460,9 @@ class StackTest(common.HeatTestCase):
self.m.ReplayAll()
test_env = environment.Environment({'flavor': 'dummy'})
self.stack = stack.Stack(self.ctx, 'stack_with_custom_constraint',
template.Template(tmpl),
environment.Environment({'flavor': 'dummy'}))
template.Template(tmpl, env=test_env))
self.stack.validate()
self.stack.store()
@ -1627,10 +1628,9 @@ class StackTest(common.HeatTestCase):
Type: Number
""")
env1 = {'parameters': {'foo': 'abc'}}
env1 = environment.Environment({'parameters': {'foo': 'abc'}})
self.stack = stack.Stack(self.ctx, 'stack_with_bad_param',
template.Template(tmpl),
env=environment.Environment(env1))
template.Template(tmpl, env=env1))
ex = self.assertRaises(exception.StackValidationFailed,
self.stack.validate)

35
heat/tests/test_stack_update.py
View File

@ -261,17 +261,18 @@ class StackUpdateTest(common.HeatTestCase):
}
}
self.stack = stack.Stack(self.ctx, 'update_test_stack',
template.Template(tmpl),
environment.Environment({'foo': 'abc'}))
self.stack = stack.Stack(
self.ctx, 'update_test_stack',
template.Template(
tmpl, env=environment.Environment({'foo': 'abc'})))
self.stack.store()
self.stack.create()
self.assertEqual((stack.Stack.CREATE, stack.Stack.COMPLETE),
self.stack.state)
env2 = environment.Environment({'foo': 'xyz'})
updated_stack = stack.Stack(self.ctx, 'updated_stack',
template.Template(tmpl),
environment.Environment({'foo': 'xyz'}))
template.Template(tmpl, env=env2))
def check_and_raise(*args):
self.assertEqual('abc', self.stack['AResource'].properties['Foo'])
@ -800,11 +801,10 @@ class StackUpdateTest(common.HeatTestCase):
'Resources': {'AResource': {'Type': 'ResourceWithPropsType',
'Properties': {'Foo': 'abc'}}}}
env1 = {'parameters': {'AParam': 'abc'}}
env1 = environment.Environment({'parameters': {'AParam': 'abc'}})
self.stack = stack.Stack(self.ctx, 'update_test_stack',
template.Template(tmpl),
disable_rollback=False,
env=environment.Environment(env1))
template.Template(tmpl, env=env1),
disable_rollback=False)
self.stack.store()
self.stack.create()
self.assertEqual((stack.Stack.CREATE, stack.Stack.COMPLETE),
@ -815,11 +815,10 @@ class StackUpdateTest(common.HeatTestCase):
'Resources': {'AResource': {'Type': 'ResourceWithPropsType',
'Properties': {'Foo': 'xyz'}}}}
env2 = {'parameters': {'BParam': 'smelly'}}
env2 = environment.Environment({'parameters': {'BParam': 'smelly'}})
updated_stack = stack.Stack(self.ctx, 'updated_stack',
template.Template(tmpl2),
disable_rollback=False,
env=environment.Environment(env2))
template.Template(tmpl2, env=env2),
disable_rollback=False)
# patch in a dummy handle_create making the replace fail when creating
# the replacement rsrc, and again on the second call (rollback)
@ -1344,11 +1343,10 @@ class StackUpdateTest(common.HeatTestCase):
'AResource': {'Type': 'ResourceWithPropsType',
'Properties': {'Foo': {'Ref': 'AParam'}}}}}
env1 = {'parameters': {'AParam': 'abc'}}
env2 = {'parameters': {'AParam': 'smelly'}}
env1 = environment.Environment({'parameters': {'AParam': 'abc'}})
env2 = environment.Environment({'parameters': {'AParam': 'smelly'}})
self.stack = stack.Stack(self.ctx, 'update_test_stack',
template.Template(tmpl),
environment.Environment(env1))
template.Template(tmpl, env=env1))
self.stack.store()
self.stack.create()
@ -1357,8 +1355,7 @@ class StackUpdateTest(common.HeatTestCase):
self.assertEqual('abc', self.stack['AResource'].properties['Foo'])
updated_stack = stack.Stack(self.ctx, 'updated_stack',
template.Template(tmpl),
environment.Environment(env2))
template.Template(tmpl, env=env2))
self.stack.update(updated_stack)
self.assertEqual((stack.Stack.UPDATE, stack.Stack.COMPLETE),
self.stack.state)

2
heat/tests/test_swiftsignal.py
View File

@ -26,7 +26,6 @@ from testtools import matchers
from heat.common import exception
from heat.common import template_format
from heat.engine.clients.os import swift
from heat.engine import environment
from heat.engine import resource
from heat.engine import rsrc_defn
from heat.engine import scheduler
@ -88,7 +87,6 @@ def create_stack(template, stack_id=None):
template = templatem.Template(tmpl)
ctx = utils.dummy_context(tenant_id='test_tenant')
st = stack.Stack(ctx, 'test_st', template,
environment.Environment(),
disable_rollback=True)
# Stub out the stack ID so we have a known value

17
heat/tests/test_template.py
View File

@ -559,17 +559,17 @@ Mappings:
self.assertRaises(KeyError, self.resolve, find, tmpl, stk)
def test_param_refs(self):
tmpl = template.Template(parameter_template)
env = environment.Environment({'foo': 'bar', 'blarg': 'wibble'})
stk = stack.Stack(self.ctx, 'test', tmpl, env)
tmpl = template.Template(parameter_template, env=env)
stk = stack.Stack(self.ctx, 'test', tmpl)
p_snippet = {"Ref": "foo"}
self.assertEqual("bar", self.resolve(p_snippet, tmpl, stk))
def test_param_ref_missing(self):
tmpl = template.Template(parameter_template)
env = environment.Environment({'foo': 'bar'})
stk = stack.Stack(self.ctx, 'test', tmpl, env)
stk.env = environment.Environment({})
tmpl = template.Template(parameter_template, env=env)
stk = stack.Stack(self.ctx, 'test', tmpl)
tmpl.env = environment.Environment({})
stk.parameters = parameters.Parameters(stk.identifier(), tmpl)
snippet = {"Ref": "foo"}
self.assertRaises(exception.UserParameterMissing,
@ -728,9 +728,9 @@ Mappings:
self.assertEqual('"foo" is "${var3}"', self.resolve(snippet, tmpl))
def test_replace_param_values(self):
tmpl = template.Template(parameter_template)
env = environment.Environment({'foo': 'wibble'})
stk = stack.Stack(self.ctx, 'test_stack', tmpl, env)
tmpl = template.Template(parameter_template, env=env)
stk = stack.Stack(self.ctx, 'test_stack', tmpl)
snippet = {"Fn::Replace": [
{'$var1': {'Ref': 'foo'}, '%var2%': {'Ref': 'blarg'}},
'$var1 is %var2%'
@ -1007,8 +1007,7 @@ class ResolveDataTest(common.HeatTestCase):
self.ctx = utils.dummy_context()
self.stack = stack.Stack(self.ctx, 'resolve_test_stack',
template.Template(empty_template),
environment.Environment({}))
template.Template(empty_template))
def resolve(self, snippet):
return function.resolve(self.stack.t.parse(self.stack, snippet))

107
heat/tests/test_validate.py
View File

@ -1245,10 +1245,9 @@ class validateTest(common.HeatTestCase):
def test_unregistered_key(self):
t = template_format.parse(test_unregistered_key)
template = parser.Template(t)
params = {'KeyName': 'not_registered'}
stack = parser.Stack(self.ctx, 'test_stack', template,
environment.Environment(params))
template = parser.Template(t, env=environment.Environment(params))
stack = parser.Stack(self.ctx, 'test_stack', template)
self._mock_get_image_id_success('image_name', 'image_id')
self.m.ReplayAll()
@ -1259,10 +1258,11 @@ class validateTest(common.HeatTestCase):
def test_unregistered_image(self):
t = template_format.parse(test_template_image)
template = parser.Template(t)
template = parser.Template(t,
env=environment.Environment(
{'KeyName': 'test'}))
stack = parser.Stack(self.ctx, 'test_stack', template,
environment.Environment({'KeyName': 'test'}))
stack = parser.Stack(self.ctx, 'test_stack', template)
self._mock_get_image_id_fail('image_name',
exception.ImageNotFound(
@ -1276,10 +1276,11 @@ class validateTest(common.HeatTestCase):
def test_duplicated_image(self):
t = template_format.parse(test_template_image)
template = parser.Template(t)
template = parser.Template(t,
env=environment.Environment(
{'KeyName': 'test'}))
stack = parser.Stack(self.ctx, 'test_stack', template,
environment.Environment({'KeyName': 'test'}))
stack = parser.Stack(self.ctx, 'test_stack', template)
self._mock_get_image_id_fail('image_name',
exception.PhysicalResourceNameAmbiguity(
@ -1295,9 +1296,10 @@ class validateTest(common.HeatTestCase):
def test_invalid_security_groups_with_nics(self):
t = template_format.parse(test_template_invalid_secgroups)
template = parser.Template(t)
stack = parser.Stack(self.ctx, 'test_stack', template,
environment.Environment({'KeyName': 'test'}))
template = parser.Template(t,
env=environment.Environment(
{'KeyName': 'test'}))
stack = parser.Stack(self.ctx, 'test_stack', template)
self._mock_get_image_id_success('image_name', 'image_id')
@ -1312,9 +1314,9 @@ class validateTest(common.HeatTestCase):
def test_invalid_security_group_ids_with_nics(self):
t = template_format.parse(test_template_invalid_secgroupids)
template = parser.Template(t)
stack = parser.Stack(self.ctx, 'test_stack', template,
environment.Environment({'KeyName': 'test'}))
template = parser.Template(
t, env=environment.Environment({'KeyName': 'test'}))
stack = parser.Stack(self.ctx, 'test_stack', template)
self._mock_get_image_id_success('image_name', 'image_id')
@ -1344,22 +1346,22 @@ class validateTest(common.HeatTestCase):
def test_validate_unique_logical_name(self):
t = template_format.parse(test_template_unique_logical_name)
template = parser.Template(t)
stack = parser.Stack(self.ctx, 'test_stack', template,
environment.Environment({'AName': 'test',
'KeyName': 'test'}))
template = parser.Template(
t, env=environment.Environment(
{'AName': 'test', 'KeyName': 'test'}))
stack = parser.Stack(self.ctx, 'test_stack', template)
self.assertRaises(exception.StackValidationFailed, stack.validate)
def test_validate_duplicate_parameters_in_group(self):
t = template_format.parse(test_template_duplicate_parameters)
template = tmpl.HOTemplate20130523(t)
stack = parser.Stack(self.ctx, 'test_stack', template,
environment.Environment({
'KeyName': 'test',
'ImageId': 'sometestid',
'db_password': 'Pass123'
}))
template = tmpl.HOTemplate20130523(
t, env=environment.Environment({
'KeyName': 'test',
'ImageId': 'sometestid',
'db_password': 'Pass123'
}))
stack = parser.Stack(self.ctx, 'test_stack', template)
exc = self.assertRaises(exception.StackValidationFailed,
stack.validate)
@ -1368,12 +1370,12 @@ class validateTest(common.HeatTestCase):
def test_validate_invalid_parameter_in_group(self):
t = template_format.parse(test_template_invalid_parameter_name)
template = tmpl.HOTemplate20130523(t)
stack = parser.Stack(self.ctx, 'test_stack', template,
environment.Environment({
'KeyName': 'test',
'ImageId': 'sometestid',
'db_password': 'Pass123'}))
template = tmpl.HOTemplate20130523(t,
env=environment.Environment({
'KeyName': 'test',
'ImageId': 'sometestid',
'db_password': 'Pass123'}))
stack = parser.Stack(self.ctx, 'test_stack', template)
exc = self.assertRaises(exception.StackValidationFailed,
stack.validate)
@ -1394,47 +1396,46 @@ class validateTest(common.HeatTestCase):
def test_validate_allowed_values_integer(self):
t = template_format.parse(test_template_allowed_integers)
template = parser.Template(t)
template = parser.Template(t,
env=environment.Environment({'size': '4'}))
# test with size parameter provided as string
stack = parser.Stack(self.ctx, 'test_stack', template,
environment.Environment({'size': '4'}))
stack = parser.Stack(self.ctx, 'test_stack', template)
self.assertIsNone(stack.validate())
# test with size parameter provided as number
stack = parser.Stack(self.ctx, 'test_stack', template,
environment.Environment({'size': 4}))
template.env = environment.Environment({'size': 4})
stack = parser.Stack(self.ctx, 'test_stack', template)
self.assertIsNone(stack.validate())
def test_validate_allowed_values_integer_str(self):
t = template_format.parse(test_template_allowed_integers_str)
template = parser.Template(t)
template = parser.Template(t,
env=environment.Environment({'size': '4'}))
# test with size parameter provided as string
stack = parser.Stack(self.ctx, 'test_stack', template,
environment.Environment({'size': '4'}))
stack = parser.Stack(self.ctx, 'test_stack', template)
self.assertIsNone(stack.validate())
# test with size parameter provided as number
stack = parser.Stack(self.ctx, 'test_stack', template,
environment.Environment({'size': 4}))
template.env = environment.Environment({'size': 4})
stack = parser.Stack(self.ctx, 'test_stack', template)
self.assertIsNone(stack.validate())
def test_validate_not_allowed_values_integer(self):
t = template_format.parse(test_template_allowed_integers)
template = parser.Template(t)
template = parser.Template(t,
env=environment.Environment({'size': '3'}))
# test with size parameter provided as string
stack = parser.Stack(self.ctx, 'test_stack', template,
environment.Environment({'size': '3'}))
stack = parser.Stack(self.ctx, 'test_stack', template)
err = self.assertRaises(exception.StackValidationFailed,
stack.validate)
self.assertIn('"3" is not an allowed value [1, 4, 8]',
six.text_type(err))
# test with size parameter provided as number
stack = parser.Stack(self.ctx, 'test_stack', template,
environment.Environment({'size': 3}))
template.env = environment.Environment({'size': 3})
stack = parser.Stack(self.ctx, 'test_stack', template)
err = self.assertRaises(exception.StackValidationFailed,
stack.validate)
self.assertIn('"3" is not an allowed value [1, 4, 8]',
@ -1442,19 +1443,19 @@ class validateTest(common.HeatTestCase):
def test_validate_not_allowed_values_integer_str(self):
t = template_format.parse(test_template_allowed_integers_str)
template = parser.Template(t)
template = parser.Template(t,
env=environment.Environment({'size': '3'}))
# test with size parameter provided as string
stack = parser.Stack(self.ctx, 'test_stack', template,
environment.Environment({'size': '3'}))
stack = parser.Stack(self.ctx, 'test_stack', template)
err = self.assertRaises(exception.StackValidationFailed,
stack.validate)
self.assertIn('"3" is not an allowed value [1, 4, 8]',
six.text_type(err))
# test with size parameter provided as number
stack = parser.Stack(self.ctx, 'test_stack', template,
environment.Environment({'size': 3}))
template.env = environment.Environment({'size': 3})
stack = parser.Stack(self.ctx, 'test_stack', template)
err = self.assertRaises(exception.StackValidationFailed,
stack.validate)
self.assertIn('"3" is not an allowed value [1, 4, 8]',

2
heat/tests/utils.py
View File

@ -96,7 +96,7 @@ def parse_stack(t, params=None, files=None, stack_name=None,
templ.store()
if stack_name is None:
stack_name = random_name()
stk = stack.Stack(ctx, stack_name, templ, stack_id,
stk = stack.Stack(ctx, stack_name, templ, stack_id=stack_id,
timeout_mins=timeout_mins)
stk.store()
return stk