openstack
/
heat
Code Issues Proposed changes

Retain references to stacks in all unit tests 

This will allow Resources to hold weak references to Stacks (so as to avoid
circular references) without causing the Stack object to be prematurely
deleted.

Change-Id: Ia76da7bc51042fb3598ef2a660d6fbf78137a37b
Related-Bug: #1454873
This commit is contained in:
Zane Bitter 2015-05-14 16:44:58 -04:00
parent 2032548c4e
commit 203b8e8ecf
35 changed files with 272 additions and 261 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
contrib/heat_docker/heat_docker/tests/test_docker_container.py
View File

@ -65,10 +65,11 @@ class DockerContainerTest(common.HeatTestCase):
def create_container(self, resource_name): def create_container(self, resource_name):
t = template_format.parse(template) t = template_format.parse(template)
stack = utils.parse_stack(t) self.stack = utils.parse_stack(t)
resource = docker_container.DockerContainer( resource = docker_container.DockerContainer(
resource_name, resource_name,
stack.t.resource_definitions(stack)[resource_name], stack) self.stack.t.resource_definitions(self.stack)[resource_name],
self.stack)
self.m.StubOutWithMock(resource, 'get_client') self.m.StubOutWithMock(resource, 'get_client')
resource.get_client().MultipleTimes().AndReturn( resource.get_client().MultipleTimes().AndReturn(
fakeclient.FakeDockerClient()) fakeclient.FakeDockerClient())
@ -94,11 +95,11 @@ class DockerContainerTest(common.HeatTestCase):
def test_create_with_name(self): def test_create_with_name(self):
t = template_format.parse(template) t = template_format.parse(template)
stack = utils.parse_stack(t) self.stack = utils.parse_stack(t)
definition = stack.t.resource_definitions(stack)['Blog'] definition = self.stack.t.resource_definitions(self.stack)['Blog']
definition['Properties']['name'] = 'super-blog' definition['Properties']['name'] = 'super-blog'
resource = docker_container.DockerContainer( resource = docker_container.DockerContainer(
'Blog', definition, stack) 'Blog', definition, self.stack)
self.m.StubOutWithMock(resource, 'get_client') self.m.StubOutWithMock(resource, 'get_client')
resource.get_client().MultipleTimes().AndReturn( resource.get_client().MultipleTimes().AndReturn(
fakeclient.FakeDockerClient()) fakeclient.FakeDockerClient())
@ -133,13 +134,13 @@ class DockerContainerTest(common.HeatTestCase):
def test_start_with_bindings_and_links(self): def test_start_with_bindings_and_links(self):
t = template_format.parse(template) t = template_format.parse(template)
stack = utils.parse_stack(t) self.stack = utils.parse_stack(t)
definition = stack.t.resource_definitions(stack)['Blog'] definition = self.stack.t.resource_definitions(self.stack)['Blog']
definition['Properties']['port_bindings'] = { definition['Properties']['port_bindings'] = {
'80/tcp': [{'HostPort': '80'}]} '80/tcp': [{'HostPort': '80'}]}
definition['Properties']['links'] = {'db': 'mysql'} definition['Properties']['links'] = {'db': 'mysql'}
resource = docker_container.DockerContainer( resource = docker_container.DockerContainer(
'Blog', definition, stack) 'Blog', definition, self.stack)
self.m.StubOutWithMock(resource, 'get_client') self.m.StubOutWithMock(resource, 'get_client')
resource.get_client().MultipleTimes().AndReturn( resource.get_client().MultipleTimes().AndReturn(
fakeclient.FakeDockerClient()) fakeclient.FakeDockerClient())
@ -223,12 +224,12 @@ class DockerContainerTest(common.HeatTestCase):
def test_start_with_restart_policy_no(self): def test_start_with_restart_policy_no(self):
t = template_format.parse(template) t = template_format.parse(template)
stack = utils.parse_stack(t) self.stack = utils.parse_stack(t)
definition = stack.t.resource_definitions(stack)['Blog'] definition = self.stack.t.resource_definitions(self.stack)['Blog']
definition['Properties']['restart_policy'] = { definition['Properties']['restart_policy'] = {
'Name': 'no', 'MaximumRetryCount': 0} 'Name': 'no', 'MaximumRetryCount': 0}
resource = docker_container.DockerContainer( resource = docker_container.DockerContainer(
'Blog', definition, stack) 'Blog', definition, self.stack)
get_client_mock = self.patchobject(resource, 'get_client') get_client_mock = self.patchobject(resource, 'get_client')
get_client_mock.return_value = fakeclient.FakeDockerClient() get_client_mock.return_value = fakeclient.FakeDockerClient()
self.assertIsNone(resource.validate()) self.assertIsNone(resource.validate())
@ -242,12 +243,12 @@ class DockerContainerTest(common.HeatTestCase):
def test_start_with_restart_policy_on_failure(self): def test_start_with_restart_policy_on_failure(self):
t = template_format.parse(template) t = template_format.parse(template)
stack = utils.parse_stack(t) self.stack = utils.parse_stack(t)
definition = stack.t.resource_definitions(stack)['Blog'] definition = self.stack.t.resource_definitions(self.stack)['Blog']
definition['Properties']['restart_policy'] = { definition['Properties']['restart_policy'] = {
'Name': 'on-failure', 'MaximumRetryCount': 10} 'Name': 'on-failure', 'MaximumRetryCount': 10}
resource = docker_container.DockerContainer( resource = docker_container.DockerContainer(
'Blog', definition, stack) 'Blog', definition, self.stack)
get_client_mock = self.patchobject(resource, 'get_client') get_client_mock = self.patchobject(resource, 'get_client')
get_client_mock.return_value = fakeclient.FakeDockerClient() get_client_mock.return_value = fakeclient.FakeDockerClient()
self.assertIsNone(resource.validate()) self.assertIsNone(resource.validate())
@ -261,12 +262,12 @@ class DockerContainerTest(common.HeatTestCase):
def test_start_with_restart_policy_always(self): def test_start_with_restart_policy_always(self):
t = template_format.parse(template) t = template_format.parse(template)
stack = utils.parse_stack(t) self.stack = utils.parse_stack(t)
definition = stack.t.resource_definitions(stack)['Blog'] definition = self.stack.t.resource_definitions(self.stack)['Blog']
definition['Properties']['restart_policy'] = { definition['Properties']['restart_policy'] = {
'Name': 'always', 'MaximumRetryCount': 0} 'Name': 'always', 'MaximumRetryCount': 0}
resource = docker_container.DockerContainer( resource = docker_container.DockerContainer(
'Blog', definition, stack) 'Blog', definition, self.stack)
get_client_mock = self.patchobject(resource, 'get_client') get_client_mock = self.patchobject(resource, 'get_client')
get_client_mock.return_value = fakeclient.FakeDockerClient() get_client_mock.return_value = fakeclient.FakeDockerClient()
self.assertIsNone(resource.validate()) self.assertIsNone(resource.validate())
@ -280,12 +281,12 @@ class DockerContainerTest(common.HeatTestCase):
def test_start_with_caps(self): def test_start_with_caps(self):
t = template_format.parse(template) t = template_format.parse(template)
stack = utils.parse_stack(t) self.stack = utils.parse_stack(t)
definition = stack.t.resource_definitions(stack)['Blog'] definition = self.stack.t.resource_definitions(self.stack)['Blog']
definition['Properties']['cap_add'] = ['NET_ADMIN'] definition['Properties']['cap_add'] = ['NET_ADMIN']
definition['Properties']['cap_drop'] = ['MKNOD'] definition['Properties']['cap_drop'] = ['MKNOD']
resource = docker_container.DockerContainer( resource = docker_container.DockerContainer(
'Blog', definition, stack) 'Blog', definition, self.stack)
get_client_mock = self.patchobject(resource, 'get_client') get_client_mock = self.patchobject(resource, 'get_client')
get_client_mock.return_value = fakeclient.FakeDockerClient() get_client_mock.return_value = fakeclient.FakeDockerClient()
self.assertIsNone(resource.validate()) self.assertIsNone(resource.validate())
@ -299,11 +300,11 @@ class DockerContainerTest(common.HeatTestCase):
def test_start_with_read_only(self): def test_start_with_read_only(self):
t = template_format.parse(template) t = template_format.parse(template)
stack = utils.parse_stack(t) self.stack = utils.parse_stack(t)
definition = stack.t.resource_definitions(stack)['Blog'] definition = self.stack.t.resource_definitions(self.stack)['Blog']
definition['Properties']['read_only'] = True definition['Properties']['read_only'] = True
resource = docker_container.DockerContainer( resource = docker_container.DockerContainer(
'Blog', definition, stack) 'Blog', definition, self.stack)
get_client_mock = self.patchobject(resource, 'get_client') get_client_mock = self.patchobject(resource, 'get_client')
get_client_mock.return_value = fakeclient.FakeDockerClient() get_client_mock.return_value = fakeclient.FakeDockerClient()
get_client_mock.return_value.set_api_version('1.17') get_client_mock.return_value.set_api_version('1.17')
@ -317,11 +318,11 @@ class DockerContainerTest(common.HeatTestCase):
def arg_for_low_api_version(self, arg, value, low_version): def arg_for_low_api_version(self, arg, value, low_version):
t = template_format.parse(template) t = template_format.parse(template)
stack = utils.parse_stack(t) self.stack = utils.parse_stack(t)
definition = stack.t.resource_definitions(stack)['Blog'] definition = self.stack.t.resource_definitions(self.stack)['Blog']
definition['Properties'][arg] = value definition['Properties'][arg] = value
my_resource = docker_container.DockerContainer( my_resource = docker_container.DockerContainer(
'Blog', definition, stack) 'Blog', definition, self.stack)
get_client_mock = self.patchobject(my_resource, 'get_client') get_client_mock = self.patchobject(my_resource, 'get_client')
get_client_mock.return_value = fakeclient.FakeDockerClient() get_client_mock.return_value = fakeclient.FakeDockerClient()
get_client_mock.return_value.set_api_version(low_version) get_client_mock.return_value.set_api_version(low_version)
@ -343,11 +344,11 @@ class DockerContainerTest(common.HeatTestCase):
def test_create_with_cpu_shares(self): def test_create_with_cpu_shares(self):
t = template_format.parse(template) t = template_format.parse(template)
stack = utils.parse_stack(t) self.stack = utils.parse_stack(t)
definition = stack.t.resource_definitions(stack)['Blog'] definition = self.stack.t.resource_definitions(self.stack)['Blog']
definition['Properties']['cpu_shares'] = 512 definition['Properties']['cpu_shares'] = 512
my_resource = docker_container.DockerContainer( my_resource = docker_container.DockerContainer(
'Blog', definition, stack) 'Blog', definition, self.stack)
get_client_mock = self.patchobject(my_resource, 'get_client') get_client_mock = self.patchobject(my_resource, 'get_client')
get_client_mock.return_value = fakeclient.FakeDockerClient() get_client_mock.return_value = fakeclient.FakeDockerClient()
self.assertIsNone(my_resource.validate()) self.assertIsNone(my_resource.validate())
@ -363,8 +364,8 @@ class DockerContainerTest(common.HeatTestCase):
def test_start_with_mapping_devices(self): def test_start_with_mapping_devices(self):
t = template_format.parse(template) t = template_format.parse(template)
stack = utils.parse_stack(t) self.stack = utils.parse_stack(t)
definition = stack.t.resource_definitions(stack)['Blog'] definition = self.stack.t.resource_definitions(self.stack)['Blog']
definition['Properties']['devices'] = ( definition['Properties']['devices'] = (
[{'path_on_host': '/dev/sda', [{'path_on_host': '/dev/sda',
'path_in_container': '/dev/xvdc', 'path_in_container': '/dev/xvdc',
@ -373,7 +374,7 @@ class DockerContainerTest(common.HeatTestCase):
'path_in_container': '/dev/xvdd', 'path_in_container': '/dev/xvdd',
'permissions': 'rw'}]) 'permissions': 'rw'}])
my_resource = docker_container.DockerContainer( my_resource = docker_container.DockerContainer(
'Blog', definition, stack) 'Blog', definition, self.stack)
get_client_mock = self.patchobject(my_resource, 'get_client') get_client_mock = self.patchobject(my_resource, 'get_client')
get_client_mock.return_value = fakeclient.FakeDockerClient() get_client_mock.return_value = fakeclient.FakeDockerClient()
self.assertIsNone(my_resource.validate()) self.assertIsNone(my_resource.validate())
@ -388,15 +389,15 @@ class DockerContainerTest(common.HeatTestCase):
def test_start_with_mapping_devices_also_with_privileged(self): def test_start_with_mapping_devices_also_with_privileged(self):
t = template_format.parse(template) t = template_format.parse(template)
stack = utils.parse_stack(t) self.stack = utils.parse_stack(t)
definition = stack.t.resource_definitions(stack)['Blog'] definition = self.stack.t.resource_definitions(self.stack)['Blog']
definition['Properties']['devices'] = ( definition['Properties']['devices'] = (
[{'path_on_host': '/dev/sdb', [{'path_on_host': '/dev/sdb',
'path_in_container': '/dev/xvdc', 'path_in_container': '/dev/xvdc',
'permissions': 'r'}]) 'permissions': 'r'}])
definition['Properties']['privileged'] = True definition['Properties']['privileged'] = True
my_resource = docker_container.DockerContainer( my_resource = docker_container.DockerContainer(
'Blog', definition, stack) 'Blog', definition, self.stack)
get_client_mock = self.patchobject(my_resource, 'get_client') get_client_mock = self.patchobject(my_resource, 'get_client')
get_client_mock.return_value = fakeclient.FakeDockerClient() get_client_mock.return_value = fakeclient.FakeDockerClient()
self.assertIsNone(my_resource.validate()) self.assertIsNone(my_resource.validate())
@ -415,13 +416,13 @@ class DockerContainerTest(common.HeatTestCase):
def test_start_with_mapping_devices_not_set_path_in_container(self): def test_start_with_mapping_devices_not_set_path_in_container(self):
t = template_format.parse(template) t = template_format.parse(template)
stack = utils.parse_stack(t) self.stack = utils.parse_stack(t)
definition = stack.t.resource_definitions(stack)['Blog'] definition = self.stack.t.resource_definitions(self.stack)['Blog']
definition['Properties']['devices'] = ( definition['Properties']['devices'] = (
[{'path_on_host': '/dev/sda', [{'path_on_host': '/dev/sda',
'permissions': 'rwm'}]) 'permissions': 'rwm'}])
my_resource = docker_container.DockerContainer( my_resource = docker_container.DockerContainer(
'Blog', definition, stack) 'Blog', definition, self.stack)
get_client_mock = self.patchobject(my_resource, 'get_client') get_client_mock = self.patchobject(my_resource, 'get_client')
get_client_mock.return_value = fakeclient.FakeDockerClient() get_client_mock.return_value = fakeclient.FakeDockerClient()
self.assertIsNone(my_resource.validate()) self.assertIsNone(my_resource.validate())
@ -435,11 +436,11 @@ class DockerContainerTest(common.HeatTestCase):
def test_create_with_cpu_set(self): def test_create_with_cpu_set(self):
t = template_format.parse(template) t = template_format.parse(template)
stack = utils.parse_stack(t) self.stack = utils.parse_stack(t)
definition = stack.t.resource_definitions(stack)['Blog'] definition = self.stack.t.resource_definitions(self.stack)['Blog']
definition['Properties']['cpu_set'] = '0-8,16-24,28' definition['Properties']['cpu_set'] = '0-8,16-24,28'
my_resource = docker_container.DockerContainer( my_resource = docker_container.DockerContainer(
'Blog', definition, stack) 'Blog', definition, self.stack)
get_client_mock = self.patchobject(my_resource, 'get_client') get_client_mock = self.patchobject(my_resource, 'get_client')
get_client_mock.return_value = fakeclient.FakeDockerClient() get_client_mock.return_value = fakeclient.FakeDockerClient()
self.assertIsNone(my_resource.validate()) self.assertIsNone(my_resource.validate())

30
contrib/heat_gnocchi/heat_gnocchi/tests/test_gnocchi_alarm.py
View File

@ -125,10 +125,10 @@ class GnocchiResourcesAlarmTest(common.HeatTestCase):
} }
).AndReturn(FakeCeilometerAlarm()) ).AndReturn(FakeCeilometerAlarm())
snippet = template_format.parse(gnocchi_resources_alarm_template) snippet = template_format.parse(gnocchi_resources_alarm_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
return gnocchi.CeilometerGnocchiResourcesAlarm( return gnocchi.CeilometerGnocchiResourcesAlarm(
'GnoResAlarm', resource_defns['GnoResAlarm'], stack) 'GnoResAlarm', resource_defns['GnoResAlarm'], self.stack)
def test_update(self): def test_update(self):
rsrc = self.create_alarm() rsrc = self.create_alarm()
@ -151,8 +151,8 @@ class GnocchiResourcesAlarmTest(common.HeatTestCase):
def _prepare_check_resource(self): def _prepare_check_resource(self):
snippet = template_format.parse(gnocchi_resources_alarm_template) snippet = template_format.parse(gnocchi_resources_alarm_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
res = stack['GnoResAlarm'] res = self.stack['GnoResAlarm']
res.ceilometer = mock.Mock() res.ceilometer = mock.Mock()
mock_alarm = mock.Mock(enabled=True, state='ok') mock_alarm = mock.Mock(enabled=True, state='ok')
res.ceilometer().alarms.get.return_value = mock_alarm res.ceilometer().alarms.get.return_value = mock_alarm
@ -260,11 +260,11 @@ class GnocchiAggregationByMetricsAlarmTest(GnocchiResourcesAlarmTest):
).AndReturn(FakeCeilometerAlarm()) ).AndReturn(FakeCeilometerAlarm())
snippet = template_format.parse( snippet = template_format.parse(
gnocchi_aggregation_by_metrics_alarm_template) gnocchi_aggregation_by_metrics_alarm_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
return gnocchi.CeilometerGnocchiAggregationByMetricsAlarm( return gnocchi.CeilometerGnocchiAggregationByMetricsAlarm(
'GnoAggregationByMetricsAlarm', 'GnoAggregationByMetricsAlarm',
resource_defns['GnoAggregationByMetricsAlarm'], stack) resource_defns['GnoAggregationByMetricsAlarm'], self.stack)
def test_update(self): def test_update(self):
rsrc = self.create_alarm() rsrc = self.create_alarm()
@ -290,8 +290,8 @@ class GnocchiAggregationByMetricsAlarmTest(GnocchiResourcesAlarmTest):
def _prepare_check_resource(self): def _prepare_check_resource(self):
snippet = template_format.parse( snippet = template_format.parse(
gnocchi_aggregation_by_metrics_alarm_template) gnocchi_aggregation_by_metrics_alarm_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
res = stack['GnoAggregationByMetricsAlarm'] res = self.stack['GnoAggregationByMetricsAlarm']
res.ceilometer = mock.Mock() res.ceilometer = mock.Mock()
mock_alarm = mock.Mock(enabled=True, state='ok') mock_alarm = mock.Mock(enabled=True, state='ok')
res.ceilometer().alarms.get.return_value = mock_alarm res.ceilometer().alarms.get.return_value = mock_alarm
@ -327,11 +327,11 @@ class GnocchiAggregationByResourcesAlarmTest(GnocchiResourcesAlarmTest):
).AndReturn(FakeCeilometerAlarm()) ).AndReturn(FakeCeilometerAlarm())
snippet = template_format.parse( snippet = template_format.parse(
gnocchi_aggregation_by_resources_alarm_template) gnocchi_aggregation_by_resources_alarm_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
return gnocchi.CeilometerGnocchiAggregationByResourcesAlarm( return gnocchi.CeilometerGnocchiAggregationByResourcesAlarm(
'GnoAggregationByResourcesAlarm', 'GnoAggregationByResourcesAlarm',
resource_defns['GnoAggregationByResourcesAlarm'], stack) resource_defns['GnoAggregationByResourcesAlarm'], self.stack)
def test_update(self): def test_update(self):
rsrc = self.create_alarm() rsrc = self.create_alarm()
@ -355,8 +355,8 @@ class GnocchiAggregationByResourcesAlarmTest(GnocchiResourcesAlarmTest):
def _prepare_check_resource(self): def _prepare_check_resource(self):
snippet = template_format.parse( snippet = template_format.parse(
gnocchi_aggregation_by_resources_alarm_template) gnocchi_aggregation_by_resources_alarm_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
res = stack['GnoAggregationByResourcesAlarm'] res = self.stack['GnoAggregationByResourcesAlarm']
res.ceilometer = mock.Mock() res.ceilometer = mock.Mock()
mock_alarm = mock.Mock(enabled=True, state='ok') mock_alarm = mock.Mock(enabled=True, state='ok')
res.ceilometer().alarms.get.return_value = mock_alarm res.ceilometer().alarms.get.return_value = mock_alarm

10
contrib/heat_manila/heat_manila/tests/test_share_type.py
View File

@ -47,14 +47,14 @@ class ManilaShareTypeTest(common.HeatTestCase):
resource._register_class("OS::Manila::ShareType", resource._register_class("OS::Manila::ShareType",
mshare_type.ManilaShareType) mshare_type.ManilaShareType)
@staticmethod def _init_share(self, stack_name, share_type_name="test_share_type"):
def _init_share(stack_name, share_type_name="test_share_type"):
# parse stack # parse stack
tmp = template_format.parse(manila_template) tmp = template_format.parse(manila_template)
stack = utils.parse_stack(tmp, stack_name=stack_name) self.stack = utils.parse_stack(tmp, stack_name=stack_name)
res_def = stack.t.resource_definitions(stack)["test_share_type"] defns = self.stack.t.resource_definitions(self.stack)
res_def = defns["test_share_type"]
share_type = mshare_type.ManilaShareType( share_type = mshare_type.ManilaShareType(
share_type_name, res_def, stack) share_type_name, res_def, self.stack)
# mock clients and plugins # mock clients and plugins
mock_client = mock.MagicMock() mock_client = mock.MagicMock()
client = mock.MagicMock(return_value=mock_client) client = mock.MagicMock(return_value=mock_client)

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

@ -358,9 +358,9 @@ class LoadBalancerTest(common.HeatTestCase):
def _mock_loadbalancer(self, lb_template, expected_name, expected_body): def _mock_loadbalancer(self, lb_template, expected_name, expected_body):
t = template_format.parse(json.dumps(lb_template)) t = template_format.parse(json.dumps(lb_template))
s = utils.parse_stack(t, stack_name=utils.random_name()) self.stack = utils.parse_stack(t, stack_name=utils.random_name())
rsrc, fake_loadbalancer = self._mock_create(s.t, s, rsrc, fake_loadbalancer = self._mock_create(self.stack.t, self.stack,
self. self.
_get_first_resource_name( _get_first_resource_name(
lb_template), lb_template),

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

@ -92,9 +92,9 @@ class CloudServersTest(common.HeatTestCase):
templ = template.Template( templ = template.Template(
t, env=environment.Environment({'key_name': 'test'})) t, env=environment.Environment({'key_name': 'test'}))
stack = parser.Stack(self.ctx, stack_name, templ, self.stack = parser.Stack(self.ctx, stack_name, templ,
stack_id=uuidutils.generate_uuid()) stack_id=uuidutils.generate_uuid())
return (templ, stack) return (templ, self.stack)
def _setup_test_server(self, return_server, name, image_id=None, def _setup_test_server(self, return_server, name, image_id=None,
override_name=False, stub_create=True, exit_code=0): override_name=False, stub_create=True, exit_code=0):

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

@ -103,15 +103,15 @@ class RackspaceDnsTest(common.HeatTestCase):
t = parsed_t t = parsed_t
templ = template.Template( templ = template.Template(
t, env=environment.Environment({'name': 'test'})) t, env=environment.Environment({'name': 'test'}))
stack = parser.Stack(utils.dummy_context(), self.stack = parser.Stack(utils.dummy_context(),
stack_name, stack_name,
templ, templ,
stack_id=str(uuid.uuid4())) stack_id=str(uuid.uuid4()))
instance = cloud_dns.CloudDns( instance = cloud_dns.CloudDns(
'%s_name' % name, '%s_name' % name,
templ.resource_definitions(stack)['domain'], templ.resource_definitions(self.stack)['domain'],
stack) self.stack)
return instance return instance
def _stubout_create(self, instance, fake_dnsinstance, **create_args): def _stubout_create(self, instance, fake_dnsinstance, **create_args):

16
heat/tests/autoscaling/test_heat_scaling_group.py
View File

@ -54,8 +54,8 @@ class TestScalingGroupTags(common.HeatTestCase):
def setUp(self): def setUp(self):
super(TestScalingGroupTags, self).setUp() super(TestScalingGroupTags, self).setUp()
t = template_format.parse(inline_templates.as_heat_template) t = template_format.parse(inline_templates.as_heat_template)
stack = utils.parse_stack(t, params=inline_templates.as_params) self.stack = utils.parse_stack(t, params=inline_templates.as_params)
self.group = stack['my-group'] self.group = self.stack['my-group']
def test_tags_default(self): def test_tags_default(self):
expected = [{'Key': 'metering.groupname', expected = [{'Key': 'metering.groupname',
@ -118,8 +118,8 @@ class TestGroupAdjust(common.HeatTestCase):
generic_resource.ResourceWithPropsAndAttrs) generic_resource.ResourceWithPropsAndAttrs)
t = template_format.parse(inline_templates.as_heat_template) t = template_format.parse(inline_templates.as_heat_template)
stack = utils.parse_stack(t, params=inline_templates.as_params) self.stack = utils.parse_stack(t, params=inline_templates.as_params)
self.group = stack['my-group'] self.group = self.stack['my-group']
self.stub_ImageConstraint_validate() self.stub_ImageConstraint_validate()
self.stub_FlavorConstraint_validate() self.stub_FlavorConstraint_validate()
self.stub_SnapshotConstraint_validate() self.stub_SnapshotConstraint_validate()
@ -292,8 +292,8 @@ class TestGroupCrud(common.HeatTestCase):
self.stub_SnapshotConstraint_validate() self.stub_SnapshotConstraint_validate()
t = template_format.parse(inline_templates.as_heat_template) t = template_format.parse(inline_templates.as_heat_template)
stack = utils.parse_stack(t, params=inline_templates.as_params) self.stack = utils.parse_stack(t, params=inline_templates.as_params)
self.group = stack['my-group'] self.group = self.stack['my-group']
self.assertIsNone(self.group.validate()) self.assertIsNone(self.group.validate())
def test_handle_create(self): def test_handle_create(self):
@ -370,8 +370,8 @@ class HeatScalingGroupAttrTest(common.HeatTestCase):
generic_resource.ResourceWithPropsAndAttrs) generic_resource.ResourceWithPropsAndAttrs)
t = template_format.parse(inline_templates.as_heat_template) t = template_format.parse(inline_templates.as_heat_template)
stack = utils.parse_stack(t, params=inline_templates.as_params) self.stack = utils.parse_stack(t, params=inline_templates.as_params)
self.group = stack['my-group'] self.group = self.stack['my-group']
self.assertIsNone(self.group.validate()) self.assertIsNone(self.group.validate())
def test_no_instance_list(self): def test_no_instance_list(self):

6
heat/tests/autoscaling/test_heat_scaling_policy.py
View File

@ -210,9 +210,9 @@ class ScalingPolicyAttrTest(common.HeatTestCase):
cfg.CONF.set_default('heat_waitcondition_server_url', cfg.CONF.set_default('heat_waitcondition_server_url',
'http://server.test:8000/v1/waitcondition') 'http://server.test:8000/v1/waitcondition')
t = template_format.parse(as_template) t = template_format.parse(as_template)
stack = utils.parse_stack(t, params=as_params) self.stack = utils.parse_stack(t, params=as_params)
self.stack_name = stack.name self.stack_name = self.stack.name
self.policy = stack['my-policy'] self.policy = self.stack['my-policy']
self.assertIsNone(self.policy.validate()) self.assertIsNone(self.policy.validate())
scheduler.TaskRunner(self.policy.create)() scheduler.TaskRunner(self.policy.create)()
self.assertEqual((self.policy.CREATE, self.policy.COMPLETE), self.assertEqual((self.policy.CREATE, self.policy.COMPLETE),

12
heat/tests/autoscaling/test_scaling_group.py
View File

@ -235,8 +235,8 @@ class TestScalingGroupTags(common.HeatTestCase):
def setUp(self): def setUp(self):
super(TestScalingGroupTags, self).setUp() super(TestScalingGroupTags, self).setUp()
t = template_format.parse(as_template) t = template_format.parse(as_template)
stack = utils.parse_stack(t, params=inline_templates.as_params) self.stack = utils.parse_stack(t, params=inline_templates.as_params)
self.group = stack['WebServerGroup'] self.group = self.stack['WebServerGroup']
def test_tags_default(self): def test_tags_default(self):
expected = [{'Key': 'metering.groupname', expected = [{'Key': 'metering.groupname',
@ -299,8 +299,8 @@ class TestGroupAdjust(common.HeatTestCase):
'http://server.test:8000/v1/waitcondition') 'http://server.test:8000/v1/waitcondition')
t = template_format.parse(as_template) t = template_format.parse(as_template)
stack = utils.parse_stack(t, params=inline_templates.as_params) self.stack = utils.parse_stack(t, params=inline_templates.as_params)
self.group = stack['WebServerGroup'] self.group = self.stack['WebServerGroup']
self.stub_ImageConstraint_validate() self.stub_ImageConstraint_validate()
self.stub_FlavorConstraint_validate() self.stub_FlavorConstraint_validate()
self.stub_SnapshotConstraint_validate() self.stub_SnapshotConstraint_validate()
@ -468,8 +468,8 @@ class TestGroupCrud(common.HeatTestCase):
'http://server.test:8000/v1/waitcondition') 'http://server.test:8000/v1/waitcondition')
t = template_format.parse(as_template) t = template_format.parse(as_template)
stack = utils.parse_stack(t, params=inline_templates.as_params) self.stack = utils.parse_stack(t, params=inline_templates.as_params)
self.group = stack['WebServerGroup'] self.group = self.stack['WebServerGroup']
self.assertIsNone(self.group.validate()) self.assertIsNone(self.group.validate())
def test_handle_create(self): def test_handle_create(self):

4
heat/tests/autoscaling/test_scaling_policy.py
View File

@ -208,8 +208,8 @@ class ScalingPolicyAttrTest(common.HeatTestCase):
def setUp(self): def setUp(self):
super(ScalingPolicyAttrTest, self).setUp() super(ScalingPolicyAttrTest, self).setUp()
t = template_format.parse(as_template) t = template_format.parse(as_template)
stack = utils.parse_stack(t, params=as_params) self.stack = utils.parse_stack(t, params=as_params)
self.policy = stack['WebServerScaleUpPolicy'] self.policy = self.stack['WebServerScaleUpPolicy']
self.assertIsNone(self.policy.validate()) self.assertIsNone(self.policy.validate())
scheduler.TaskRunner(self.policy.create)() scheduler.TaskRunner(self.policy.create)()
self.assertEqual((self.policy.CREATE, self.policy.COMPLETE), self.assertEqual((self.policy.CREATE, self.policy.COMPLETE),

7
heat/tests/aws/test_instance.py
View File

@ -108,9 +108,10 @@ class InstancesTest(common.HeatTestCase):
def _setup_test_instance(self, return_server, name, image_id=None, def _setup_test_instance(self, return_server, name, image_id=None,
stub_create=True): stub_create=True):
stack_name = '%s_s' % name stack_name = '%s_s' % name
tmpl, stack = self._get_test_template(stack_name, image_id) tmpl, self.stack = self._get_test_template(stack_name, image_id)
resource_defns = tmpl.resource_definitions(stack) resource_defns = tmpl.resource_definitions(self.stack)
instance = instances.Instance(name, resource_defns['WebServer'], stack) instance = instances.Instance(name, resource_defns['WebServer'],
self.stack)
bdm = {"vdb": "9ef5496e-7426-446a-bbc8-01f84d9c9972:snap::True"} bdm = {"vdb": "9ef5496e-7426-446a-bbc8-01f84d9c9972:snap::True"}
self._mock_get_image_id_success(image_id or 'CentOS 5.2', 1) self._mock_get_image_id_success(image_id or 'CentOS 5.2', 1)

20
heat/tests/aws/test_instance_network.py
View File

@ -204,13 +204,13 @@ class instancesTest(common.HeatTestCase):
'SubnetId': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861'} 'SubnetId': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861'}
tmpl = template.Template(t, tmpl = template.Template(t,
env=environment.Environment(kwargs)) env=environment.Environment(kwargs))
stack = parser.Stack(utils.dummy_context(), stack_name, tmpl, self.stack = parser.Stack(utils.dummy_context(), stack_name, tmpl,
stack_id=str(uuid.uuid4())) stack_id=str(uuid.uuid4()))
image_id = 'CentOS 5.2' image_id = 'CentOS 5.2'
t['Resources']['WebServer']['Properties']['ImageId'] = image_id t['Resources']['WebServer']['Properties']['ImageId'] = image_id
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
instance = instances.Instance('%s_name' % name, instance = instances.Instance('%s_name' % name,
resource_defns['WebServer'], stack) resource_defns['WebServer'], self.stack)
metadata = instance.metadata_get() metadata = instance.metadata_get()
self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') self.m.StubOutWithMock(nova.NovaClientPlugin, '_create')
@ -259,18 +259,18 @@ class instancesTest(common.HeatTestCase):
'SubnetId': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861'} 'SubnetId': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861'}
tmpl = template.Template(t, tmpl = template.Template(t,
env=environment.Environment(kwargs)) env=environment.Environment(kwargs))
stack = parser.Stack(utils.dummy_context(), stack_name, tmpl, self.stack = parser.Stack(utils.dummy_context(), stack_name, tmpl,
stack_id=str(uuid.uuid4())) stack_id=str(uuid.uuid4()))
image_id = 'CentOS 5.2' image_id = 'CentOS 5.2'
t['Resources']['WebServer']['Properties']['ImageId'] = image_id t['Resources']['WebServer']['Properties']['ImageId'] = image_id
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
nic = net_interfaces.NetworkInterface('%s_nic' % name, nic = net_interfaces.NetworkInterface('%s_nic' % name,
resource_defns['nic1'], resource_defns['nic1'],
stack) self.stack)
instance = instances.Instance('%s_name' % name, instance = instances.Instance('%s_name' % name,
resource_defns['WebServer'], stack) resource_defns['WebServer'], self.stack)
metadata = instance.metadata_get() metadata = instance.metadata_get()
self._mock_get_image_id_success(image_id, 1) self._mock_get_image_id_success(image_id, 1)
@ -310,7 +310,7 @@ class instancesTest(common.HeatTestCase):
# create network interface # create network interface
scheduler.TaskRunner(nic.create)() scheduler.TaskRunner(nic.create)()
stack.resources["nic1"] = nic self.stack.resources["nic1"] = nic
scheduler.TaskRunner(instance.create)() scheduler.TaskRunner(instance.create)()
return instance return instance

12
heat/tests/aws/test_loadbalancer.py
View File

@ -159,11 +159,11 @@ class LoadBalancerTest(common.HeatTestCase):
if not include_magic: if not include_magic:
del template['Parameters']['KeyName'] del template['Parameters']['KeyName']
del template['Parameters']['LbFlavor'] del template['Parameters']['LbFlavor']
stack = utils.parse_stack(template) self.stack = utils.parse_stack(template)
resource_name = 'LoadBalancer' resource_name = 'LoadBalancer'
lb_defn = stack.t.resource_definitions(stack)[resource_name] lb_defn = self.stack.t.resource_definitions(self.stack)[resource_name]
return lb.LoadBalancer(resource_name, lb_defn, stack) return lb.LoadBalancer(resource_name, lb_defn, self.stack)
def test_loadbalancer_refid(self): def test_loadbalancer_refid(self):
rsrc = self.setup_loadbalancer() rsrc = self.setup_loadbalancer()
@ -253,10 +253,10 @@ class LoadBalancerTest(common.HeatTestCase):
class HaProxyConfigTest(common.HeatTestCase): class HaProxyConfigTest(common.HeatTestCase):
def setUp(self): def setUp(self):
super(HaProxyConfigTest, self).setUp() super(HaProxyConfigTest, self).setUp()
stack = utils.parse_stack(template_format.parse(lb_template)) self.stack = utils.parse_stack(template_format.parse(lb_template))
resource_name = 'LoadBalancer' resource_name = 'LoadBalancer'
lb_defn = stack.t.resource_definitions(stack)[resource_name] lb_defn = self.stack.t.resource_definitions(self.stack)[resource_name]
self.lb = lb.LoadBalancer(resource_name, lb_defn, stack) self.lb = lb.LoadBalancer(resource_name, lb_defn, self.stack)
self.lb.client_plugin = mock.Mock() self.lb.client_plugin = mock.Mock()
def _mock_props(self, props): def _mock_props(self, props):

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

@ -593,7 +593,8 @@ class WaitConditionUpdateTest(common.HeatTestCase):
self.m.VerifyAll() self.m.VerifyAll()
self.m.UnsetStubs() self.m.UnsetStubs()
wait_condition_handle = self.stack['WaitHandle'] handle_stack = self.stack
wait_condition_handle = handle_stack['WaitHandle']
test_metadata = {'Data': 'foo', 'Reason': 'bar', test_metadata = {'Data': 'foo', 'Reason': 'bar',
'Status': 'SUCCESS', 'UniqueId': '1'} 'Status': 'SUCCESS', 'UniqueId': '1'}
self._handle_signal(wait_condition_handle, test_metadata, 2) self._handle_signal(wait_condition_handle, test_metadata, 2)

18
heat/tests/neutron/test_neutron_firewall.py
View File

@ -86,10 +86,10 @@ class FirewallTest(common.HeatTestCase):
).AndReturn({'firewall': {'id': '5678'}}) ).AndReturn({'firewall': {'id': '5678'}})
snippet = template_format.parse(firewall_template) snippet = template_format.parse(firewall_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
return firewall.Firewall( return firewall.Firewall(
'firewall', resource_defns['firewall'], stack) 'firewall', resource_defns['firewall'], self.stack)
def test_create(self): def test_create(self):
rsrc = self.create_firewall() rsrc = self.create_firewall()
@ -214,10 +214,10 @@ class FirewallPolicyTest(common.HeatTestCase):
).AndReturn({'firewall_policy': {'id': '5678'}}) ).AndReturn({'firewall_policy': {'id': '5678'}})
snippet = template_format.parse(firewall_policy_template) snippet = template_format.parse(firewall_policy_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
return firewall.FirewallPolicy( return firewall.FirewallPolicy(
'firewall_policy', resource_defns['firewall_policy'], stack) 'firewall_policy', resource_defns['firewall_policy'], self.stack)
def test_create(self): def test_create(self):
rsrc = self.create_firewall_policy() rsrc = self.create_firewall_policy()
@ -340,10 +340,10 @@ class FirewallRuleTest(common.HeatTestCase):
).AndReturn({'firewall_rule': {'id': '5678'}}) ).AndReturn({'firewall_rule': {'id': '5678'}})
snippet = template_format.parse(firewall_rule_template) snippet = template_format.parse(firewall_rule_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
return firewall.FirewallRule( return firewall.FirewallRule(
'firewall_rule', resource_defns['firewall_rule'], stack) 'firewall_rule', resource_defns['firewall_rule'], self.stack)
def test_create(self): def test_create(self):
rsrc = self.create_firewall_rule() rsrc = self.create_firewall_rule()

93
heat/tests/neutron/test_neutron_loadbalancer.py
View File

@ -170,10 +170,10 @@ class HealthMonitorTest(common.HeatTestCase):
).AndReturn({'health_monitor': {'id': '5678'}}) ).AndReturn({'health_monitor': {'id': '5678'}})
snippet = template_format.parse(health_monitor_template) snippet = template_format.parse(health_monitor_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
return loadbalancer.HealthMonitor( return loadbalancer.HealthMonitor(
'monitor', resource_defns['monitor'], stack) 'monitor', resource_defns['monitor'], self.stack)
def test_create(self): def test_create(self):
rsrc = self.create_health_monitor() rsrc = self.create_health_monitor()
@ -191,10 +191,10 @@ class HealthMonitorTest(common.HeatTestCase):
self.m.ReplayAll() self.m.ReplayAll()
snippet = template_format.parse(health_monitor_template) snippet = template_format.parse(health_monitor_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
rsrc = loadbalancer.HealthMonitor( rsrc = loadbalancer.HealthMonitor(
'monitor', resource_defns['monitor'], stack) 'monitor', resource_defns['monitor'], self.stack)
error = self.assertRaises(exception.ResourceFailure, error = self.assertRaises(exception.ResourceFailure,
scheduler.TaskRunner(rsrc.create)) scheduler.TaskRunner(rsrc.create))
self.assertEqual( self.assertEqual(
@ -344,10 +344,10 @@ class PoolTest(common.HeatTestCase):
snippet = template_format.parse(pool_template_deprecated) snippet = template_format.parse(pool_template_deprecated)
neutronclient.Client.create_vip(stvippsn neutronclient.Client.create_vip(stvippsn
).AndReturn({'vip': {'id': 'xyz'}}) ).AndReturn({'vip': {'id': 'xyz'}})
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
return loadbalancer.Pool( return loadbalancer.Pool(
'pool', resource_defns['pool'], stack) 'pool', resource_defns['pool'], self.stack)
def test_create(self): def test_create(self):
self._test_create() self._test_create()
@ -398,10 +398,10 @@ class PoolTest(common.HeatTestCase):
{'vip': {'status': 'ACTIVE'}}) {'vip': {'status': 'ACTIVE'}})
snippet = template_format.parse(pool_template) snippet = template_format.parse(pool_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
rsrc = loadbalancer.Pool( rsrc = loadbalancer.Pool(
'pool', resource_defns['pool'], stack) 'pool', resource_defns['pool'], self.stack)
self.m.ReplayAll() self.m.ReplayAll()
scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.create)()
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
@ -432,10 +432,10 @@ class PoolTest(common.HeatTestCase):
{'pool': {'status': 'ERROR', 'name': '5678'}}) {'pool': {'status': 'ERROR', 'name': '5678'}})
snippet = template_format.parse(pool_template) snippet = template_format.parse(pool_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
rsrc = loadbalancer.Pool( rsrc = loadbalancer.Pool(
'pool', resource_defns['pool'], stack) 'pool', resource_defns['pool'], self.stack)
self.m.ReplayAll() self.m.ReplayAll()
error = self.assertRaises(exception.ResourceFailure, error = self.assertRaises(exception.ResourceFailure,
scheduler.TaskRunner(rsrc.create)) scheduler.TaskRunner(rsrc.create))
@ -470,10 +470,10 @@ class PoolTest(common.HeatTestCase):
{'vip': {'status': 'SOMETHING', 'name': 'xyz'}}) {'vip': {'status': 'SOMETHING', 'name': 'xyz'}})
snippet = template_format.parse(pool_template) snippet = template_format.parse(pool_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
rsrc = loadbalancer.Pool( rsrc = loadbalancer.Pool(
'pool', resource_defns['pool'], stack) 'pool', resource_defns['pool'], self.stack)
self.m.ReplayAll() self.m.ReplayAll()
error = self.assertRaises(exception.ResourceFailure, error = self.assertRaises(exception.ResourceFailure,
scheduler.TaskRunner(rsrc.create)) scheduler.TaskRunner(rsrc.create))
@ -499,10 +499,10 @@ class PoolTest(common.HeatTestCase):
self.m.ReplayAll() self.m.ReplayAll()
snippet = template_format.parse(pool_template) snippet = template_format.parse(pool_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
rsrc = loadbalancer.Pool( rsrc = loadbalancer.Pool(
'pool', resource_defns['pool'], stack) 'pool', resource_defns['pool'], self.stack)
error = self.assertRaises(exception.ResourceFailure, error = self.assertRaises(exception.ResourceFailure,
scheduler.TaskRunner(rsrc.create)) scheduler.TaskRunner(rsrc.create))
self.assertEqual( self.assertEqual(
@ -538,10 +538,10 @@ class PoolTest(common.HeatTestCase):
{'vip': {'status': 'ACTIVE'}}) {'vip': {'status': 'ACTIVE'}})
snippet = template_format.parse(pool_with_session_persistence_template) snippet = template_format.parse(pool_with_session_persistence_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
rsrc = loadbalancer.Pool( rsrc = loadbalancer.Pool(
'pool', resource_defns['pool'], stack) 'pool', resource_defns['pool'], self.stack)
self.m.ReplayAll() self.m.ReplayAll()
scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.create)()
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
@ -558,9 +558,10 @@ class PoolTest(common.HeatTestCase):
persistence['type'] = 'APP_COOKIE' persistence['type'] = 'APP_COOKIE'
persistence['cookie_name'] = None persistence['cookie_name'] = None
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
resource = loadbalancer.Pool('pool', resource_defns['pool'], stack) resource = loadbalancer.Pool('pool', resource_defns['pool'],
self.stack)
error = self.assertRaises(exception.StackValidationFailed, error = self.assertRaises(exception.StackValidationFailed,
resource.validate) resource.validate)
@ -569,9 +570,10 @@ class PoolTest(common.HeatTestCase):
def test_validation_not_failing_without_session_persistence(self): def test_validation_not_failing_without_session_persistence(self):
snippet = template_format.parse(pool_template) snippet = template_format.parse(pool_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
resource = loadbalancer.Pool('pool', resource_defns['pool'], stack) resource = loadbalancer.Pool('pool', resource_defns['pool'],
self.stack)
self.stub_SubnetConstraint_validate() self.stub_SubnetConstraint_validate()
self.m.ReplayAll() self.m.ReplayAll()
self.assertIsNone(resource.validate()) self.assertIsNone(resource.validate())
@ -610,9 +612,10 @@ class PoolTest(common.HeatTestCase):
persistence['type'] = 'HTTP_COOKIE' persistence['type'] = 'HTTP_COOKIE'
del persistence['cookie_name'] del persistence['cookie_name']
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
resource = loadbalancer.Pool('pool', resource_defns['pool'], stack) resource = loadbalancer.Pool('pool', resource_defns['pool'],
self.stack)
# assert that properties contain cookie_name property with None value # assert that properties contain cookie_name property with None value
persistence = resource.properties['vip']['session_persistence'] persistence = resource.properties['vip']['session_persistence']
@ -760,11 +763,11 @@ class PoolTest(common.HeatTestCase):
'5678', {'health_monitor': {'id': 'mon789'}}) '5678', {'health_monitor': {'id': 'mon789'}})
snippet = template_format.parse(pool_template) snippet = template_format.parse(pool_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
snippet['resources']['pool']['properties']['monitors'] = [ snippet['resources']['pool']['properties']['monitors'] = [
'mon123', 'mon456'] 'mon123', 'mon456']
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
rsrc = loadbalancer.Pool('pool', resource_defns['pool'], stack) rsrc = loadbalancer.Pool('pool', resource_defns['pool'], self.stack)
self.m.ReplayAll() self.m.ReplayAll()
scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.create)()
@ -792,10 +795,10 @@ class PoolMemberTest(common.HeatTestCase):
'address': '1.2.3.4', 'admin_state_up': True}} 'address': '1.2.3.4', 'admin_state_up': True}}
).AndReturn({'member': {'id': 'member5678'}}) ).AndReturn({'member': {'id': 'member5678'}})
snippet = template_format.parse(member_template) snippet = template_format.parse(member_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
return loadbalancer.PoolMember( return loadbalancer.PoolMember(
'member', resource_defns['member'], stack) 'member', resource_defns['member'], self.stack)
def test_create(self): def test_create(self):
rsrc = self.create_member() rsrc = self.create_member()
@ -816,10 +819,10 @@ class PoolMemberTest(common.HeatTestCase):
snippet = template_format.parse(member_template) snippet = template_format.parse(member_template)
snippet['resources']['member']['properties']['admin_state_up'] = False snippet['resources']['member']['properties']['admin_state_up'] = False
snippet['resources']['member']['properties']['weight'] = 100 snippet['resources']['member']['properties']['weight'] = 100
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
rsrc = loadbalancer.PoolMember( rsrc = loadbalancer.PoolMember(
'member', resource_defns['member'], stack) 'member', resource_defns['member'], self.stack)
self.m.ReplayAll() self.m.ReplayAll()
scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.create)()
@ -893,10 +896,10 @@ class LoadBalancerTest(common.HeatTestCase):
'address': '1.2.3.4'}} 'address': '1.2.3.4'}}
).AndReturn({'member': {'id': 'member5678'}}) ).AndReturn({'member': {'id': 'member5678'}})
snippet = template_format.parse(lb_template) snippet = template_format.parse(lb_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
return loadbalancer.LoadBalancer( return loadbalancer.LoadBalancer(
'lb', resource_defns['lb'], stack) 'lb', resource_defns['lb'], self.stack)
def test_create(self): def test_create(self):
rsrc = self.create_load_balancer() rsrc = self.create_load_balancer()

12
heat/tests/neutron/test_neutron_metering.py
View File

@ -67,10 +67,10 @@ class MeteringLabelTest(common.HeatTestCase):
}).AndReturn({'metering_label': {'id': '1234'}}) }).AndReturn({'metering_label': {'id': '1234'}})
snippet = template_format.parse(metering_template) snippet = template_format.parse(metering_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
return metering.MeteringLabel( return metering.MeteringLabel(
'label', resource_defns['label'], stack) 'label', resource_defns['label'], self.stack)
def test_create(self): def test_create(self):
rsrc = self.create_metering_label() rsrc = self.create_metering_label()
@ -180,10 +180,10 @@ class MeteringRuleTest(common.HeatTestCase):
}).AndReturn({'metering_label_rule': {'id': '5678'}}) }).AndReturn({'metering_label_rule': {'id': '5678'}})
snippet = template_format.parse(metering_template) snippet = template_format.parse(metering_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
return metering.MeteringRule( return metering.MeteringRule(
'rule', resource_defns['rule'], stack) 'rule', resource_defns['rule'], self.stack)
def test_create(self): def test_create(self):
rsrc = self.create_metering_label_rule() rsrc = self.create_metering_label_rule()

12
heat/tests/neutron/test_neutron_network_gateway.py
View File

@ -129,11 +129,11 @@ class NeutronNetworkGatewayTest(common.HeatTestCase):
t = template_format.parse(gw_template) t = template_format.parse(gw_template)
stack = utils.parse_stack(t) self.stack = utils.parse_stack(t)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
rsrc = network_gateway.NetworkGateway( rsrc = network_gateway.NetworkGateway(
'test_network_gateway', 'test_network_gateway',
resource_defns['NetworkGateway'], stack) resource_defns['NetworkGateway'], self.stack)
return rsrc return rsrc
def prepare_create_network_gateway(self, resolve_neutron=True): def prepare_create_network_gateway(self, resolve_neutron=True):
@ -180,11 +180,11 @@ class NeutronNetworkGatewayTest(common.HeatTestCase):
else: else:
t = template_format.parse(gw_template_deprecated) t = template_format.parse(gw_template_deprecated)
stack = utils.parse_stack(t) self.stack = utils.parse_stack(t)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
rsrc = network_gateway.NetworkGateway( rsrc = network_gateway.NetworkGateway(
'test_network_gateway', 'test_network_gateway',
resource_defns['NetworkGateway'], stack) resource_defns['NetworkGateway'], self.stack)
return rsrc return rsrc
def _test_network_gateway_create(self, resolve_neutron=True): def _test_network_gateway_create(self, resolve_neutron=True):

7
heat/tests/neutron/test_neutron_provider_net.py
View File

@ -88,10 +88,11 @@ class NeutronProviderNetTest(common.HeatTestCase):
).AndReturn(stpna) ).AndReturn(stpna)
t = template_format.parse(provider_network_template) t = template_format.parse(provider_network_template)
stack = utils.parse_stack(t) self.stack = utils.parse_stack(t)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
rsrc = provider_net.ProviderNet( rsrc = provider_net.ProviderNet(
'provider_net', resource_defns['provider_network_vlan'], stack) 'provider_net', resource_defns['provider_network_vlan'],
self.stack)
return rsrc return rsrc

14
heat/tests/test_ceilometer_alarm.py
View File

@ -441,8 +441,8 @@ class CeilometerAlarmTest(common.HeatTestCase):
def _prepare_check_resource(self): def _prepare_check_resource(self):
snippet = template_format.parse(not_string_alarm_template) snippet = template_format.parse(not_string_alarm_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
res = stack['MEMAlarmHigh'] res = self.stack['MEMAlarmHigh']
res.ceilometer = mock.Mock() res.ceilometer = mock.Mock()
mock_alarm = mock.Mock(enabled=True, state='ok') mock_alarm = mock.Mock(enabled=True, state='ok')
res.ceilometer().alarms.get.return_value = mock_alarm res.ceilometer().alarms.get.return_value = mock_alarm
@ -499,10 +499,10 @@ class CombinationAlarmTest(common.HeatTestCase):
'operator': u'and'} 'operator': u'and'}
).AndReturn(FakeCeilometerAlarm()) ).AndReturn(FakeCeilometerAlarm())
snippet = template_format.parse(combination_alarm_template) snippet = template_format.parse(combination_alarm_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
return alarm.CombinationAlarm( return alarm.CombinationAlarm(
'CombinAlarm', resource_defns['CombinAlarm'], stack) 'CombinAlarm', resource_defns['CombinAlarm'], self.stack)
def test_create(self): def test_create(self):
rsrc = self.create_alarm() rsrc = self.create_alarm()
@ -596,8 +596,8 @@ class CombinationAlarmTest(common.HeatTestCase):
def _prepare_check_resource(self): def _prepare_check_resource(self):
snippet = template_format.parse(combination_alarm_template) snippet = template_format.parse(combination_alarm_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
res = stack['CombinAlarm'] res = self.stack['CombinAlarm']
res.ceilometer = mock.Mock() res.ceilometer = mock.Mock()
mock_alarm = mock.Mock(enabled=True, state='ok') mock_alarm = mock.Mock(enabled=True, state='ok')
res.ceilometer().alarms.get.return_value = mock_alarm res.ceilometer().alarms.get.return_value = mock_alarm

10
heat/tests/test_instance_group.py
View File

@ -34,13 +34,13 @@ class TestInstanceGroup(common.HeatTestCase):
def setUp(self): def setUp(self):
super(TestInstanceGroup, self).setUp() super(TestInstanceGroup, self).setUp()
t = template_format.parse(inline_templates.as_template) t = template_format.parse(inline_templates.as_template)
stack = utils.parse_stack(t, params=inline_templates.as_params) self.stack = utils.parse_stack(t, params=inline_templates.as_params)
self.defn = rsrc_defn.ResourceDefinition( self.defn = rsrc_defn.ResourceDefinition(
'asg', 'OS::Heat::InstanceGroup', 'asg', 'OS::Heat::InstanceGroup',
{'Size': 2, 'AvailabilityZones': ['zoneb'], {'Size': 2, 'AvailabilityZones': ['zoneb'],
'LaunchConfigurationName': 'config'}) 'LaunchConfigurationName': 'config'})
self.instance_group = instgrp.InstanceGroup('asg', self.instance_group = instgrp.InstanceGroup('asg',
self.defn, stack) self.defn, self.stack)
def test_child_template(self): def test_child_template(self):
self.instance_group._create_template = mock.Mock(return_value='tpl') self.instance_group._create_template = mock.Mock(return_value='tpl')
@ -327,14 +327,14 @@ class ReplaceTest(common.HeatTestCase):
resource._register_class('ResourceWithPropsAndAttrs', resource._register_class('ResourceWithPropsAndAttrs',
generic_resource.ResourceWithPropsAndAttrs) generic_resource.ResourceWithPropsAndAttrs)
t = template_format.parse(inline_templates.as_template) t = template_format.parse(inline_templates.as_template)
stack = utils.parse_stack(t, params=inline_templates.as_params) self.stack = utils.parse_stack(t, params=inline_templates.as_params)
lc = self.create_launch_config(t, stack) lc = self.create_launch_config(t, self.stack)
lcid = lc.FnGetRefId() lcid = lc.FnGetRefId()
self.defn = rsrc_defn.ResourceDefinition( self.defn = rsrc_defn.ResourceDefinition(
'asg', 'OS::Heat::InstanceGroup', 'asg', 'OS::Heat::InstanceGroup',
{'Size': 2, 'AvailabilityZones': ['zoneb'], {'Size': 2, 'AvailabilityZones': ['zoneb'],
'LaunchConfigurationName': lcid}) 'LaunchConfigurationName': lcid})
self.group = instgrp.InstanceGroup('asg', self.defn, stack) self.group = instgrp.InstanceGroup('asg', self.defn, self.stack)
self.group._lb_reload = mock.Mock() self.group._lb_reload = mock.Mock()
self.group.update_with_template = mock.Mock() self.group.update_with_template = mock.Mock()

8
heat/tests/test_nested_stack.py
View File

@ -311,9 +311,9 @@ Outputs:
self.ctx = utils.dummy_context('test_username', 'aaaa', 'password') self.ctx = utils.dummy_context('test_username', 'aaaa', 'password')
empty_template = {"HeatTemplateFormatVersion": "2012-12-12"} empty_template = {"HeatTemplateFormatVersion": "2012-12-12"}
stack = parser.Stack(self.ctx, 'test', self.stack = parser.Stack(self.ctx, 'test',
template.Template(empty_template)) template.Template(empty_template))
stack.store() self.stack.store()
self.patchobject(urlfetch, 'get', return_value=self.nested_template) self.patchobject(urlfetch, 'get', return_value=self.nested_template)
self.nested_parsed = yaml.load(self.nested_template) self.nested_parsed = yaml.load(self.nested_template)
@ -324,7 +324,7 @@ Outputs:
{"TemplateURL": "https://server.test/the.template", {"TemplateURL": "https://server.test/the.template",
"Parameters": self.nested_params}) "Parameters": self.nested_params})
self.res = stack_res.NestedStack('test_t_res', self.res = stack_res.NestedStack('test_t_res',
self.defn, stack) self.defn, self.stack)
self.assertIsNone(self.res.validate()) self.assertIsNone(self.res.validate())
self.res._store() self.res._store()

14
heat/tests/test_nova_floatingip.py
View File

@ -89,12 +89,12 @@ class NovaFloatingIPTest(common.HeatTestCase):
) )
template = template_format.parse(floating_ip_template) template = template_format.parse(floating_ip_template)
stack = utils.parse_stack(template) self.stack = utils.parse_stack(template)
floating_ip = stack.t.resource_definitions(stack)['MyFloatingIP'] defns = self.stack.t.resource_definitions(self.stack)
return nova_floatingip.NovaFloatingIp('MyFloatingIP', return nova_floatingip.NovaFloatingIp('MyFloatingIP',
floating_ip, defns['MyFloatingIP'],
stack) self.stack)
def prepare_floating_ip_assoc(self): def prepare_floating_ip_assoc(self):
nova.NovaClientPlugin._create().AndReturn( nova.NovaClientPlugin._create().AndReturn(
@ -109,12 +109,12 @@ class NovaFloatingIPTest(common.HeatTestCase):
) )
template = template_format.parse(floating_ip_template_with_assoc) template = template_format.parse(floating_ip_template_with_assoc)
stack = utils.parse_stack(template) self.stack = utils.parse_stack(template)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
floating_ip_assoc = resource_defns['MyFloatingIPAssociation'] floating_ip_assoc = resource_defns['MyFloatingIPAssociation']
return nova_floatingip.NovaFloatingIpAssociation( return nova_floatingip.NovaFloatingIpAssociation(
'MyFloatingIPAssociation', floating_ip_assoc, stack) 'MyFloatingIPAssociation', floating_ip_assoc, self.stack)
def test_floating_ip_create(self): def test_floating_ip_create(self):
rsrc = self.prepare_floating_ip() rsrc = self.prepare_floating_ip()

6
heat/tests/test_nova_keypair.py
View File

@ -56,9 +56,9 @@ class NovaKeyPairTest(common.HeatTestCase):
return mkey return mkey
def _get_test_resource(self, template): def _get_test_resource(self, template):
stack = utils.parse_stack(template) self.stack = utils.parse_stack(template)
definition = stack.t.resource_definitions(stack)['kp'] definition = self.stack.t.resource_definitions(self.stack)['kp']
kp_res = nova_keypair.KeyPair('kp', definition, stack) kp_res = nova_keypair.KeyPair('kp', definition, self.stack)
self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') self.m.StubOutWithMock(nova.NovaClientPlugin, '_create')
nova.NovaClientPlugin._create().AndReturn(self.fake_nova) nova.NovaClientPlugin._create().AndReturn(self.fake_nova)
return kp_res return kp_res

36
heat/tests/test_nova_servergroup.py
View File

@ -47,8 +47,8 @@ class NovaServerGroupTest(common.HeatTestCase):
def _init_template(self, sg_template): def _init_template(self, sg_template):
template = template_format.parse(json.dumps(sg_template)) template = template_format.parse(json.dumps(sg_template))
stack = utils.parse_stack(template) self.stack = utils.parse_stack(template)
self.sg = stack['ServerGroup'] self.sg = self.stack['ServerGroup']
# create mock clients and objects # create mock clients and objects
nova = mock.MagicMock() nova = mock.MagicMock()
self.sg.nova = mock.MagicMock(return_value=nova) self.sg.nova = mock.MagicMock(return_value=nova)
@ -56,24 +56,24 @@ class NovaServerGroupTest(common.HeatTestCase):
def _create_sg(self, name): def _create_sg(self, name):
if name: if name:
sg = sg_template['resources']['ServerGroup'] sg = sg_template['resources']['ServerGroup']
sg['properties']['name'] = name sg['properties']['name'] = name
self._init_template(sg_template) self._init_template(sg_template)
self.sg_mgr.create.return_value = FakeGroup(name) self.sg_mgr.create.return_value = FakeGroup(name)
else: else:
try: try:
sg = sg_template['resources']['ServerGroup'] sg = sg_template['resources']['ServerGroup']
del sg['properties']['name'] del sg['properties']['name']
except Exception: except Exception:
pass pass
self._init_template(sg_template) self._init_template(sg_template)
name = 'test' name = 'test'
n = name n = name
def fake_create(name, policies): def fake_create(name, policies):
self.assertTrue(len(name) > 1) self.assertTrue(len(name) > 1)
return FakeGroup(n) return FakeGroup(n)
self.sg_mgr.create = fake_create self.sg_mgr.create = fake_create
scheduler.TaskRunner(self.sg.create)() scheduler.TaskRunner(self.sg.create)()
self.assertEqual((self.sg.CREATE, self.sg.COMPLETE), self.assertEqual((self.sg.CREATE, self.sg.COMPLETE),
self.sg.state) self.sg.state)

12
heat/tests/test_os_database.py
View File

@ -107,15 +107,15 @@ class OSDBInstanceTest(common.HeatTestCase):
def _setup_test_clouddbinstance(self, name, t): def _setup_test_clouddbinstance(self, name, t):
stack_name = '%s_stack' % name stack_name = '%s_stack' % name
template = tmpl.Template(t) template = tmpl.Template(t)
stack = parser.Stack(utils.dummy_context(), self.stack = parser.Stack(utils.dummy_context(),
stack_name, stack_name,
template, template,
stack_id=str(uuid.uuid4())) stack_id=str(uuid.uuid4()))
instance = os_database.OSDBInstance( instance = os_database.OSDBInstance(
'%s_name' % name, '%s_name' % name,
template.resource_definitions(stack)['MySqlCloudDB'], template.resource_definitions(self.stack)['MySqlCloudDB'],
stack) self.stack)
return instance return instance
def _stubout_common_create(self): def _stubout_common_create(self):

5
heat/tests/test_properties.py
View File

@ -1102,7 +1102,10 @@ class PropertiesTest(common.HeatTestCase):
class rsrc(object): class rsrc(object):
action = INIT = "INIT" action = INIT = "INIT"
stack = {'another_res': rsrc()} class DummyStack(dict):
pass
stack = DummyStack(another_res=rsrc())
# define properties with function and constraint # define properties with function and constraint
props = properties.Properties( props = properties.Properties(

11
heat/tests/test_provider_template.py
View File

@ -838,16 +838,17 @@ class TemplateResourceCrudTest(common.HeatTestCase):
resource._register_class('DummyResource', DummyResource) resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry': env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}}) {'DummyResource': 'test_resource.template'}})
stack = parser.Stack(self.ctx, 'test_stack', self.stack = parser.Stack(self.ctx, 'test_stack',
template.Template(empty_template, files=files, template.Template(empty_template,
env=env), files=files,
stack_id=str(uuid.uuid4())) env=env),
stack_id=str(uuid.uuid4()))
self.defn = rsrc_defn.ResourceDefinition('test_t_res', self.defn = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource", "DummyResource",
{"Foo": "bar"}) {"Foo": "bar"})
self.res = template_resource.TemplateResource('test_t_res', self.res = template_resource.TemplateResource('test_t_res',
self.defn, stack) self.defn, self.stack)
self.assertIsNone(self.res.validate()) self.assertIsNone(self.res.validate())
def test_handle_create(self): def test_handle_create(self):

6
heat/tests/test_restarter.py
View File

@ -45,10 +45,10 @@ class RestarterTest(common.HeatTestCase):
def create_restarter(self): def create_restarter(self):
snippet = template_format.parse(restarter_template) snippet = template_format.parse(restarter_template)
stack = utils.parse_stack(snippet) self.stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack) resource_defns = self.stack.t.resource_definitions(self.stack)
restarter = ha_restarter.Restarter( restarter = ha_restarter.Restarter(
'restarter', resource_defns['restarter'], stack) 'restarter', resource_defns['restarter'], self.stack)
nova.NovaClientPlugin.get_server = mock.Mock( nova.NovaClientPlugin.get_server = mock.Mock(
return_value=mock.MagicMock()) return_value=mock.MagicMock())
restarter.handle_create = mock.Mock(return_value=None) restarter.handle_create = mock.Mock(return_value=None)

4
heat/tests/test_sahara_cluster.py
View File

@ -73,8 +73,8 @@ class SaharaClusterTest(common.HeatTestCase):
self.t = template_format.parse(cluster_stack_template) self.t = template_format.parse(cluster_stack_template)
def _init_cluster(self, template): def _init_cluster(self, template):
stack = utils.parse_stack(template) self.stack = utils.parse_stack(template)
cluster = stack['super-cluster'] cluster = self.stack['super-cluster']
return cluster return cluster
def _create_cluster(self, template): def _create_cluster(self, template):

8
heat/tests/test_sahara_templates.py
View File

@ -89,8 +89,8 @@ class SaharaNodeGroupTemplateTest(common.HeatTestCase):
self.t = template_format.parse(node_group_template) self.t = template_format.parse(node_group_template)
def _init_ngt(self, template): def _init_ngt(self, template):
stack = utils.parse_stack(template) self.stack = utils.parse_stack(template)
return stack['node-group'] return self.stack['node-group']
def test_ngt_resource_mapping(self): def test_ngt_resource_mapping(self):
ngt = self._init_ngt(self.t) ngt = self._init_ngt(self.t)
@ -211,8 +211,8 @@ class SaharaClusterTemplateTest(common.HeatTestCase):
self.t = template_format.parse(cluster_template) self.t = template_format.parse(cluster_template)
def _init_ct(self, template): def _init_ct(self, template):
stack = utils.parse_stack(template) self.stack = utils.parse_stack(template)
return stack['cluster-template'] return self.stack['cluster-template']
def test_ct_resource_mapping(self): def test_ct_resource_mapping(self):
ct = self._init_ct(self.t) ct = self._init_ct(self.t)

12
heat/tests/test_server.py
View File

@ -127,9 +127,9 @@ class ServersTest(common.HeatTestCase):
return (templ, stack) return (templ, stack)
def _prepare_server_check(self): def _prepare_server_check(self):
templ, stack = self._setup_test_stack('server_check') templ, self.stack = self._setup_test_stack('server_check')
server = self.fc.servers.list()[1] server = self.fc.servers.list()[1]
res = stack['WebServer'] res = self.stack['WebServer']
res.nova = mock.Mock() res.nova = mock.Mock()
res.nova().servers.get = mock.Mock(return_value=server) res.nova().servers.get = mock.Mock(return_value=server)
return res return res
@ -183,11 +183,11 @@ class ServersTest(common.HeatTestCase):
server_rebuild=False): server_rebuild=False):
stack_name = '%s_s' % name stack_name = '%s_s' % name
server_name = str(name) if override_name else None server_name = str(name) if override_name else None
tmpl, stack = self._get_test_template(stack_name, server_name, tmpl, self.stack = self._get_test_template(stack_name, server_name,
image_id) image_id)
resource_defns = tmpl.resource_definitions(stack) resource_defns = tmpl.resource_definitions(self.stack)
server = servers.Server(str(name), resource_defns['WebServer'], server = servers.Server(str(name), resource_defns['WebServer'],
stack) self.stack)
self._mock_get_image_id_success(image_id or 'CentOS 5.2', 1, self._mock_get_image_id_success(image_id or 'CentOS 5.2', 1,
server_rebuild=server_rebuild) server_rebuild=server_rebuild)

8
heat/tests/test_server_tags.py
View File

@ -69,13 +69,13 @@ class ServerTagsTest(common.HeatTestCase):
template = tmpl.Template(t, template = tmpl.Template(t,
env=environment.Environment( env=environment.Environment(
{'KeyName': 'test'})) {'KeyName': 'test'}))
stack = parser.Stack(utils.dummy_context(), stack_name, template, self.stack = parser.Stack(utils.dummy_context(), stack_name, template,
stack_id=str(uuid.uuid4())) stack_id=str(uuid.uuid4()))
t['Resources']['WebServer']['Properties']['Tags'] = intags t['Resources']['WebServer']['Properties']['Tags'] = intags
resource_defns = template.resource_definitions(stack) resource_defns = template.resource_definitions(self.stack)
instance = instances.Instance(stack_name, instance = instances.Instance(stack_name,
resource_defns['WebServer'], stack) resource_defns['WebServer'], self.stack)
self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') self.m.StubOutWithMock(nova.NovaClientPlugin, '_create')
nova.NovaClientPlugin._create().AndReturn(self.fc) nova.NovaClientPlugin._create().AndReturn(self.fc)

8
heat/tests/test_stack_user.py
View File

@ -48,8 +48,8 @@ class StackUserTest(common.HeatTestCase):
resource_name='user', create_project=True, resource_name='user', create_project=True,
password=None): password=None):
t = template_format.parse(user_template) t = template_format.parse(user_template)
stack = utils.parse_stack(t, stack_name=stack_name) self.stack = utils.parse_stack(t, stack_name=stack_name)
rsrc = stack[resource_name] rsrc = self.stack[resource_name]
self.m.StubOutWithMock(stack_user.StackUser, 'keystone') self.m.StubOutWithMock(stack_user.StackUser, 'keystone')
stack_user.StackUser.keystone().MultipleTimes().AndReturn(self.fc) stack_user.StackUser.keystone().MultipleTimes().AndReturn(self.fc)
@ -58,9 +58,9 @@ class StackUserTest(common.HeatTestCase):
self.m.StubOutWithMock(fakes.FakeKeystoneClient, self.m.StubOutWithMock(fakes.FakeKeystoneClient,
'create_stack_domain_project') 'create_stack_domain_project')
fakes.FakeKeystoneClient.create_stack_domain_project( fakes.FakeKeystoneClient.create_stack_domain_project(
stack.id).AndReturn(project_id) self.stack.id).AndReturn(project_id)
else: else:
stack.set_stack_user_project_id(project_id) self.stack.set_stack_user_project_id(project_id)
rsrc._store() rsrc._store()
self.m.StubOutWithMock(short_id, 'get_id') self.m.StubOutWithMock(short_id, 'get_id')

4
heat/tests/test_swift.py
View File

@ -363,8 +363,8 @@ class swiftTest(common.HeatTestCase):
def _get_check_resource(self): def _get_check_resource(self):
t = template_format.parse(swift_template) t = template_format.parse(swift_template)
stack = utils.parse_stack(t) self.stack = utils.parse_stack(t)
res = self.create_resource(t, stack, 'SwiftContainer') res = self.create_resource(t, self.stack, 'SwiftContainer')
res.swift = mock.Mock() res.swift = mock.Mock()
return res return res