diff --git a/contrib/heat_docker/heat_docker/tests/test_docker_container.py b/contrib/heat_docker/heat_docker/tests/test_docker_container.py
index e8525fdf31..2dd5218776 100644
--- a/contrib/heat_docker/heat_docker/tests/test_docker_container.py
+++ b/contrib/heat_docker/heat_docker/tests/test_docker_container.py
@@ -65,10 +65,11 @@ class DockerContainerTest(common.HeatTestCase):
 
     def create_container(self, resource_name):
         t = template_format.parse(template)
-        stack = utils.parse_stack(t)
+        self.stack = utils.parse_stack(t)
         resource = docker_container.DockerContainer(
             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')
         resource.get_client().MultipleTimes().AndReturn(
             fakeclient.FakeDockerClient())
@@ -94,11 +95,11 @@ class DockerContainerTest(common.HeatTestCase):
 
     def test_create_with_name(self):
         t = template_format.parse(template)
-        stack = utils.parse_stack(t)
-        definition = stack.t.resource_definitions(stack)['Blog']
+        self.stack = utils.parse_stack(t)
+        definition = self.stack.t.resource_definitions(self.stack)['Blog']
         definition['Properties']['name'] = 'super-blog'
         resource = docker_container.DockerContainer(
-            'Blog', definition, stack)
+            'Blog', definition, self.stack)
         self.m.StubOutWithMock(resource, 'get_client')
         resource.get_client().MultipleTimes().AndReturn(
             fakeclient.FakeDockerClient())
@@ -133,13 +134,13 @@ class DockerContainerTest(common.HeatTestCase):
 
     def test_start_with_bindings_and_links(self):
         t = template_format.parse(template)
-        stack = utils.parse_stack(t)
-        definition = stack.t.resource_definitions(stack)['Blog']
+        self.stack = utils.parse_stack(t)
+        definition = self.stack.t.resource_definitions(self.stack)['Blog']
         definition['Properties']['port_bindings'] = {
             '80/tcp': [{'HostPort': '80'}]}
         definition['Properties']['links'] = {'db': 'mysql'}
         resource = docker_container.DockerContainer(
-            'Blog', definition, stack)
+            'Blog', definition, self.stack)
         self.m.StubOutWithMock(resource, 'get_client')
         resource.get_client().MultipleTimes().AndReturn(
             fakeclient.FakeDockerClient())
@@ -223,12 +224,12 @@ class DockerContainerTest(common.HeatTestCase):
 
     def test_start_with_restart_policy_no(self):
         t = template_format.parse(template)
-        stack = utils.parse_stack(t)
-        definition = stack.t.resource_definitions(stack)['Blog']
+        self.stack = utils.parse_stack(t)
+        definition = self.stack.t.resource_definitions(self.stack)['Blog']
         definition['Properties']['restart_policy'] = {
             'Name': 'no', 'MaximumRetryCount': 0}
         resource = docker_container.DockerContainer(
-            'Blog', definition, stack)
+            'Blog', definition, self.stack)
         get_client_mock = self.patchobject(resource, 'get_client')
         get_client_mock.return_value = fakeclient.FakeDockerClient()
         self.assertIsNone(resource.validate())
@@ -242,12 +243,12 @@ class DockerContainerTest(common.HeatTestCase):
 
     def test_start_with_restart_policy_on_failure(self):
         t = template_format.parse(template)
-        stack = utils.parse_stack(t)
-        definition = stack.t.resource_definitions(stack)['Blog']
+        self.stack = utils.parse_stack(t)
+        definition = self.stack.t.resource_definitions(self.stack)['Blog']
         definition['Properties']['restart_policy'] = {
             'Name': 'on-failure', 'MaximumRetryCount': 10}
         resource = docker_container.DockerContainer(
-            'Blog', definition, stack)
+            'Blog', definition, self.stack)
         get_client_mock = self.patchobject(resource, 'get_client')
         get_client_mock.return_value = fakeclient.FakeDockerClient()
         self.assertIsNone(resource.validate())
@@ -261,12 +262,12 @@ class DockerContainerTest(common.HeatTestCase):
 
     def test_start_with_restart_policy_always(self):
         t = template_format.parse(template)
-        stack = utils.parse_stack(t)
-        definition = stack.t.resource_definitions(stack)['Blog']
+        self.stack = utils.parse_stack(t)
+        definition = self.stack.t.resource_definitions(self.stack)['Blog']
         definition['Properties']['restart_policy'] = {
             'Name': 'always', 'MaximumRetryCount': 0}
         resource = docker_container.DockerContainer(
-            'Blog', definition, stack)
+            'Blog', definition, self.stack)
         get_client_mock = self.patchobject(resource, 'get_client')
         get_client_mock.return_value = fakeclient.FakeDockerClient()
         self.assertIsNone(resource.validate())
@@ -280,12 +281,12 @@ class DockerContainerTest(common.HeatTestCase):
 
     def test_start_with_caps(self):
         t = template_format.parse(template)
-        stack = utils.parse_stack(t)
-        definition = stack.t.resource_definitions(stack)['Blog']
+        self.stack = utils.parse_stack(t)
+        definition = self.stack.t.resource_definitions(self.stack)['Blog']
         definition['Properties']['cap_add'] = ['NET_ADMIN']
         definition['Properties']['cap_drop'] = ['MKNOD']
         resource = docker_container.DockerContainer(
-            'Blog', definition, stack)
+            'Blog', definition, self.stack)
         get_client_mock = self.patchobject(resource, 'get_client')
         get_client_mock.return_value = fakeclient.FakeDockerClient()
         self.assertIsNone(resource.validate())
@@ -299,11 +300,11 @@ class DockerContainerTest(common.HeatTestCase):
 
     def test_start_with_read_only(self):
         t = template_format.parse(template)
-        stack = utils.parse_stack(t)
-        definition = stack.t.resource_definitions(stack)['Blog']
+        self.stack = utils.parse_stack(t)
+        definition = self.stack.t.resource_definitions(self.stack)['Blog']
         definition['Properties']['read_only'] = True
         resource = docker_container.DockerContainer(
-            'Blog', definition, stack)
+            'Blog', definition, self.stack)
         get_client_mock = self.patchobject(resource, 'get_client')
         get_client_mock.return_value = fakeclient.FakeDockerClient()
         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):
         t = template_format.parse(template)
-        stack = utils.parse_stack(t)
-        definition = stack.t.resource_definitions(stack)['Blog']
+        self.stack = utils.parse_stack(t)
+        definition = self.stack.t.resource_definitions(self.stack)['Blog']
         definition['Properties'][arg] = value
         my_resource = docker_container.DockerContainer(
-            'Blog', definition, stack)
+            'Blog', definition, self.stack)
         get_client_mock = self.patchobject(my_resource, 'get_client')
         get_client_mock.return_value = fakeclient.FakeDockerClient()
         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):
         t = template_format.parse(template)
-        stack = utils.parse_stack(t)
-        definition = stack.t.resource_definitions(stack)['Blog']
+        self.stack = utils.parse_stack(t)
+        definition = self.stack.t.resource_definitions(self.stack)['Blog']
         definition['Properties']['cpu_shares'] = 512
         my_resource = docker_container.DockerContainer(
-            'Blog', definition, stack)
+            'Blog', definition, self.stack)
         get_client_mock = self.patchobject(my_resource, 'get_client')
         get_client_mock.return_value = fakeclient.FakeDockerClient()
         self.assertIsNone(my_resource.validate())
@@ -363,8 +364,8 @@ class DockerContainerTest(common.HeatTestCase):
 
     def test_start_with_mapping_devices(self):
         t = template_format.parse(template)
-        stack = utils.parse_stack(t)
-        definition = stack.t.resource_definitions(stack)['Blog']
+        self.stack = utils.parse_stack(t)
+        definition = self.stack.t.resource_definitions(self.stack)['Blog']
         definition['Properties']['devices'] = (
             [{'path_on_host': '/dev/sda',
               'path_in_container': '/dev/xvdc',
@@ -373,7 +374,7 @@ class DockerContainerTest(common.HeatTestCase):
               'path_in_container': '/dev/xvdd',
               'permissions': 'rw'}])
         my_resource = docker_container.DockerContainer(
-            'Blog', definition, stack)
+            'Blog', definition, self.stack)
         get_client_mock = self.patchobject(my_resource, 'get_client')
         get_client_mock.return_value = fakeclient.FakeDockerClient()
         self.assertIsNone(my_resource.validate())
@@ -388,15 +389,15 @@ class DockerContainerTest(common.HeatTestCase):
 
     def test_start_with_mapping_devices_also_with_privileged(self):
         t = template_format.parse(template)
-        stack = utils.parse_stack(t)
-        definition = stack.t.resource_definitions(stack)['Blog']
+        self.stack = utils.parse_stack(t)
+        definition = self.stack.t.resource_definitions(self.stack)['Blog']
         definition['Properties']['devices'] = (
             [{'path_on_host': '/dev/sdb',
               'path_in_container': '/dev/xvdc',
               'permissions': 'r'}])
         definition['Properties']['privileged'] = True
         my_resource = docker_container.DockerContainer(
-            'Blog', definition, stack)
+            'Blog', definition, self.stack)
         get_client_mock = self.patchobject(my_resource, 'get_client')
         get_client_mock.return_value = fakeclient.FakeDockerClient()
         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):
         t = template_format.parse(template)
-        stack = utils.parse_stack(t)
-        definition = stack.t.resource_definitions(stack)['Blog']
+        self.stack = utils.parse_stack(t)
+        definition = self.stack.t.resource_definitions(self.stack)['Blog']
         definition['Properties']['devices'] = (
             [{'path_on_host': '/dev/sda',
               'permissions': 'rwm'}])
         my_resource = docker_container.DockerContainer(
-            'Blog', definition, stack)
+            'Blog', definition, self.stack)
         get_client_mock = self.patchobject(my_resource, 'get_client')
         get_client_mock.return_value = fakeclient.FakeDockerClient()
         self.assertIsNone(my_resource.validate())
@@ -435,11 +436,11 @@ class DockerContainerTest(common.HeatTestCase):
 
     def test_create_with_cpu_set(self):
         t = template_format.parse(template)
-        stack = utils.parse_stack(t)
-        definition = stack.t.resource_definitions(stack)['Blog']
+        self.stack = utils.parse_stack(t)
+        definition = self.stack.t.resource_definitions(self.stack)['Blog']
         definition['Properties']['cpu_set'] = '0-8,16-24,28'
         my_resource = docker_container.DockerContainer(
-            'Blog', definition, stack)
+            'Blog', definition, self.stack)
         get_client_mock = self.patchobject(my_resource, 'get_client')
         get_client_mock.return_value = fakeclient.FakeDockerClient()
         self.assertIsNone(my_resource.validate())
diff --git a/contrib/heat_gnocchi/heat_gnocchi/tests/test_gnocchi_alarm.py b/contrib/heat_gnocchi/heat_gnocchi/tests/test_gnocchi_alarm.py
index 4ea6438de8..3d056a364f 100644
--- a/contrib/heat_gnocchi/heat_gnocchi/tests/test_gnocchi_alarm.py
+++ b/contrib/heat_gnocchi/heat_gnocchi/tests/test_gnocchi_alarm.py
@@ -125,10 +125,10 @@ class GnocchiResourcesAlarmTest(common.HeatTestCase):
             }
         ).AndReturn(FakeCeilometerAlarm())
         snippet = template_format.parse(gnocchi_resources_alarm_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         return gnocchi.CeilometerGnocchiResourcesAlarm(
-            'GnoResAlarm', resource_defns['GnoResAlarm'], stack)
+            'GnoResAlarm', resource_defns['GnoResAlarm'], self.stack)
 
     def test_update(self):
         rsrc = self.create_alarm()
@@ -151,8 +151,8 @@ class GnocchiResourcesAlarmTest(common.HeatTestCase):
 
     def _prepare_check_resource(self):
         snippet = template_format.parse(gnocchi_resources_alarm_template)
-        stack = utils.parse_stack(snippet)
-        res = stack['GnoResAlarm']
+        self.stack = utils.parse_stack(snippet)
+        res = self.stack['GnoResAlarm']
         res.ceilometer = mock.Mock()
         mock_alarm = mock.Mock(enabled=True, state='ok')
         res.ceilometer().alarms.get.return_value = mock_alarm
@@ -260,11 +260,11 @@ class GnocchiAggregationByMetricsAlarmTest(GnocchiResourcesAlarmTest):
         ).AndReturn(FakeCeilometerAlarm())
         snippet = template_format.parse(
             gnocchi_aggregation_by_metrics_alarm_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         return gnocchi.CeilometerGnocchiAggregationByMetricsAlarm(
             'GnoAggregationByMetricsAlarm',
-            resource_defns['GnoAggregationByMetricsAlarm'], stack)
+            resource_defns['GnoAggregationByMetricsAlarm'], self.stack)
 
     def test_update(self):
         rsrc = self.create_alarm()
@@ -290,8 +290,8 @@ class GnocchiAggregationByMetricsAlarmTest(GnocchiResourcesAlarmTest):
     def _prepare_check_resource(self):
         snippet = template_format.parse(
             gnocchi_aggregation_by_metrics_alarm_template)
-        stack = utils.parse_stack(snippet)
-        res = stack['GnoAggregationByMetricsAlarm']
+        self.stack = utils.parse_stack(snippet)
+        res = self.stack['GnoAggregationByMetricsAlarm']
         res.ceilometer = mock.Mock()
         mock_alarm = mock.Mock(enabled=True, state='ok')
         res.ceilometer().alarms.get.return_value = mock_alarm
@@ -327,11 +327,11 @@ class GnocchiAggregationByResourcesAlarmTest(GnocchiResourcesAlarmTest):
         ).AndReturn(FakeCeilometerAlarm())
         snippet = template_format.parse(
             gnocchi_aggregation_by_resources_alarm_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         return gnocchi.CeilometerGnocchiAggregationByResourcesAlarm(
             'GnoAggregationByResourcesAlarm',
-            resource_defns['GnoAggregationByResourcesAlarm'], stack)
+            resource_defns['GnoAggregationByResourcesAlarm'], self.stack)
 
     def test_update(self):
         rsrc = self.create_alarm()
@@ -355,8 +355,8 @@ class GnocchiAggregationByResourcesAlarmTest(GnocchiResourcesAlarmTest):
     def _prepare_check_resource(self):
         snippet = template_format.parse(
             gnocchi_aggregation_by_resources_alarm_template)
-        stack = utils.parse_stack(snippet)
-        res = stack['GnoAggregationByResourcesAlarm']
+        self.stack = utils.parse_stack(snippet)
+        res = self.stack['GnoAggregationByResourcesAlarm']
         res.ceilometer = mock.Mock()
         mock_alarm = mock.Mock(enabled=True, state='ok')
         res.ceilometer().alarms.get.return_value = mock_alarm
diff --git a/contrib/heat_manila/heat_manila/tests/test_share_type.py b/contrib/heat_manila/heat_manila/tests/test_share_type.py
index 09f81775e9..2f1a17eab5 100644
--- a/contrib/heat_manila/heat_manila/tests/test_share_type.py
+++ b/contrib/heat_manila/heat_manila/tests/test_share_type.py
@@ -47,14 +47,14 @@ class ManilaShareTypeTest(common.HeatTestCase):
         resource._register_class("OS::Manila::ShareType",
                                  mshare_type.ManilaShareType)
 
-    @staticmethod
-    def _init_share(stack_name, share_type_name="test_share_type"):
+    def _init_share(self, stack_name, share_type_name="test_share_type"):
         # parse stack
         tmp = template_format.parse(manila_template)
-        stack = utils.parse_stack(tmp, stack_name=stack_name)
-        res_def = stack.t.resource_definitions(stack)["test_share_type"]
+        self.stack = utils.parse_stack(tmp, stack_name=stack_name)
+        defns = self.stack.t.resource_definitions(self.stack)
+        res_def = defns["test_share_type"]
         share_type = mshare_type.ManilaShareType(
-            share_type_name, res_def, stack)
+            share_type_name, res_def, self.stack)
         # mock clients and plugins
         mock_client = mock.MagicMock()
         client = mock.MagicMock(return_value=mock_client)
diff --git a/contrib/rackspace/rackspace/tests/test_cloud_loadbalancer.py b/contrib/rackspace/rackspace/tests/test_cloud_loadbalancer.py
index baa5b391c4..21f4752d47 100644
--- a/contrib/rackspace/rackspace/tests/test_cloud_loadbalancer.py
+++ b/contrib/rackspace/rackspace/tests/test_cloud_loadbalancer.py
@@ -358,9 +358,9 @@ class LoadBalancerTest(common.HeatTestCase):
 
     def _mock_loadbalancer(self, lb_template, expected_name, expected_body):
         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.
                                                     _get_first_resource_name(
                                                         lb_template),
diff --git a/contrib/rackspace/rackspace/tests/test_rackspace_cloud_server.py b/contrib/rackspace/rackspace/tests/test_rackspace_cloud_server.py
index b9f1ee903b..cf1715d698 100644
--- a/contrib/rackspace/rackspace/tests/test_rackspace_cloud_server.py
+++ b/contrib/rackspace/rackspace/tests/test_rackspace_cloud_server.py
@@ -92,9 +92,9 @@ class CloudServersTest(common.HeatTestCase):
         templ = template.Template(
             t, env=environment.Environment({'key_name': 'test'}))
 
-        stack = parser.Stack(self.ctx, stack_name, templ,
-                             stack_id=uuidutils.generate_uuid())
-        return (templ, stack)
+        self.stack = parser.Stack(self.ctx, stack_name, templ,
+                                  stack_id=uuidutils.generate_uuid())
+        return (templ, self.stack)
 
     def _setup_test_server(self, return_server, name, image_id=None,
                            override_name=False, stub_create=True, exit_code=0):
diff --git a/contrib/rackspace/rackspace/tests/test_rackspace_dns.py b/contrib/rackspace/rackspace/tests/test_rackspace_dns.py
index b4ce960e00..f582f69c9a 100644
--- a/contrib/rackspace/rackspace/tests/test_rackspace_dns.py
+++ b/contrib/rackspace/rackspace/tests/test_rackspace_dns.py
@@ -103,15 +103,15 @@ class RackspaceDnsTest(common.HeatTestCase):
         t = parsed_t
         templ = template.Template(
             t, env=environment.Environment({'name': 'test'}))
-        stack = parser.Stack(utils.dummy_context(),
-                             stack_name,
-                             templ,
-                             stack_id=str(uuid.uuid4()))
+        self.stack = parser.Stack(utils.dummy_context(),
+                                  stack_name,
+                                  templ,
+                                  stack_id=str(uuid.uuid4()))
 
         instance = cloud_dns.CloudDns(
             '%s_name' % name,
-            templ.resource_definitions(stack)['domain'],
-            stack)
+            templ.resource_definitions(self.stack)['domain'],
+            self.stack)
         return instance
 
     def _stubout_create(self, instance, fake_dnsinstance, **create_args):
diff --git a/heat/tests/autoscaling/test_heat_scaling_group.py b/heat/tests/autoscaling/test_heat_scaling_group.py
index db287f9951..488c7dbf20 100644
--- a/heat/tests/autoscaling/test_heat_scaling_group.py
+++ b/heat/tests/autoscaling/test_heat_scaling_group.py
@@ -54,8 +54,8 @@ class TestScalingGroupTags(common.HeatTestCase):
     def setUp(self):
         super(TestScalingGroupTags, self).setUp()
         t = template_format.parse(inline_templates.as_heat_template)
-        stack = utils.parse_stack(t, params=inline_templates.as_params)
-        self.group = stack['my-group']
+        self.stack = utils.parse_stack(t, params=inline_templates.as_params)
+        self.group = self.stack['my-group']
 
     def test_tags_default(self):
         expected = [{'Key': 'metering.groupname',
@@ -118,8 +118,8 @@ class TestGroupAdjust(common.HeatTestCase):
                                  generic_resource.ResourceWithPropsAndAttrs)
 
         t = template_format.parse(inline_templates.as_heat_template)
-        stack = utils.parse_stack(t, params=inline_templates.as_params)
-        self.group = stack['my-group']
+        self.stack = utils.parse_stack(t, params=inline_templates.as_params)
+        self.group = self.stack['my-group']
         self.stub_ImageConstraint_validate()
         self.stub_FlavorConstraint_validate()
         self.stub_SnapshotConstraint_validate()
@@ -292,8 +292,8 @@ class TestGroupCrud(common.HeatTestCase):
         self.stub_SnapshotConstraint_validate()
 
         t = template_format.parse(inline_templates.as_heat_template)
-        stack = utils.parse_stack(t, params=inline_templates.as_params)
-        self.group = stack['my-group']
+        self.stack = utils.parse_stack(t, params=inline_templates.as_params)
+        self.group = self.stack['my-group']
         self.assertIsNone(self.group.validate())
 
     def test_handle_create(self):
@@ -370,8 +370,8 @@ class HeatScalingGroupAttrTest(common.HeatTestCase):
                                  generic_resource.ResourceWithPropsAndAttrs)
 
         t = template_format.parse(inline_templates.as_heat_template)
-        stack = utils.parse_stack(t, params=inline_templates.as_params)
-        self.group = stack['my-group']
+        self.stack = utils.parse_stack(t, params=inline_templates.as_params)
+        self.group = self.stack['my-group']
         self.assertIsNone(self.group.validate())
 
     def test_no_instance_list(self):
diff --git a/heat/tests/autoscaling/test_heat_scaling_policy.py b/heat/tests/autoscaling/test_heat_scaling_policy.py
index 39fadf1596..e81329cef2 100644
--- a/heat/tests/autoscaling/test_heat_scaling_policy.py
+++ b/heat/tests/autoscaling/test_heat_scaling_policy.py
@@ -210,9 +210,9 @@ class ScalingPolicyAttrTest(common.HeatTestCase):
         cfg.CONF.set_default('heat_waitcondition_server_url',
                              'http://server.test:8000/v1/waitcondition')
         t = template_format.parse(as_template)
-        stack = utils.parse_stack(t, params=as_params)
-        self.stack_name = stack.name
-        self.policy = stack['my-policy']
+        self.stack = utils.parse_stack(t, params=as_params)
+        self.stack_name = self.stack.name
+        self.policy = self.stack['my-policy']
         self.assertIsNone(self.policy.validate())
         scheduler.TaskRunner(self.policy.create)()
         self.assertEqual((self.policy.CREATE, self.policy.COMPLETE),
diff --git a/heat/tests/autoscaling/test_scaling_group.py b/heat/tests/autoscaling/test_scaling_group.py
index 650fceab26..37d8784a1d 100644
--- a/heat/tests/autoscaling/test_scaling_group.py
+++ b/heat/tests/autoscaling/test_scaling_group.py
@@ -235,8 +235,8 @@ class TestScalingGroupTags(common.HeatTestCase):
     def setUp(self):
         super(TestScalingGroupTags, self).setUp()
         t = template_format.parse(as_template)
-        stack = utils.parse_stack(t, params=inline_templates.as_params)
-        self.group = stack['WebServerGroup']
+        self.stack = utils.parse_stack(t, params=inline_templates.as_params)
+        self.group = self.stack['WebServerGroup']
 
     def test_tags_default(self):
         expected = [{'Key': 'metering.groupname',
@@ -299,8 +299,8 @@ class TestGroupAdjust(common.HeatTestCase):
                              'http://server.test:8000/v1/waitcondition')
 
         t = template_format.parse(as_template)
-        stack = utils.parse_stack(t, params=inline_templates.as_params)
-        self.group = stack['WebServerGroup']
+        self.stack = utils.parse_stack(t, params=inline_templates.as_params)
+        self.group = self.stack['WebServerGroup']
         self.stub_ImageConstraint_validate()
         self.stub_FlavorConstraint_validate()
         self.stub_SnapshotConstraint_validate()
@@ -468,8 +468,8 @@ class TestGroupCrud(common.HeatTestCase):
                              'http://server.test:8000/v1/waitcondition')
 
         t = template_format.parse(as_template)
-        stack = utils.parse_stack(t, params=inline_templates.as_params)
-        self.group = stack['WebServerGroup']
+        self.stack = utils.parse_stack(t, params=inline_templates.as_params)
+        self.group = self.stack['WebServerGroup']
         self.assertIsNone(self.group.validate())
 
     def test_handle_create(self):
diff --git a/heat/tests/autoscaling/test_scaling_policy.py b/heat/tests/autoscaling/test_scaling_policy.py
index a85f9123c4..6074053910 100644
--- a/heat/tests/autoscaling/test_scaling_policy.py
+++ b/heat/tests/autoscaling/test_scaling_policy.py
@@ -208,8 +208,8 @@ class ScalingPolicyAttrTest(common.HeatTestCase):
     def setUp(self):
         super(ScalingPolicyAttrTest, self).setUp()
         t = template_format.parse(as_template)
-        stack = utils.parse_stack(t, params=as_params)
-        self.policy = stack['WebServerScaleUpPolicy']
+        self.stack = utils.parse_stack(t, params=as_params)
+        self.policy = self.stack['WebServerScaleUpPolicy']
         self.assertIsNone(self.policy.validate())
         scheduler.TaskRunner(self.policy.create)()
         self.assertEqual((self.policy.CREATE, self.policy.COMPLETE),
diff --git a/heat/tests/aws/test_instance.py b/heat/tests/aws/test_instance.py
index 15107751cd..ca5de12eb9 100644
--- a/heat/tests/aws/test_instance.py
+++ b/heat/tests/aws/test_instance.py
@@ -108,9 +108,10 @@ class InstancesTest(common.HeatTestCase):
     def _setup_test_instance(self, return_server, name, image_id=None,
                              stub_create=True):
         stack_name = '%s_s' % name
-        tmpl, stack = self._get_test_template(stack_name, image_id)
-        resource_defns = tmpl.resource_definitions(stack)
-        instance = instances.Instance(name, resource_defns['WebServer'], stack)
+        tmpl, self.stack = self._get_test_template(stack_name, image_id)
+        resource_defns = tmpl.resource_definitions(self.stack)
+        instance = instances.Instance(name, resource_defns['WebServer'],
+                                      self.stack)
         bdm = {"vdb": "9ef5496e-7426-446a-bbc8-01f84d9c9972:snap::True"}
 
         self._mock_get_image_id_success(image_id or 'CentOS 5.2', 1)
diff --git a/heat/tests/aws/test_instance_network.py b/heat/tests/aws/test_instance_network.py
index 6329201ac4..4d1535503b 100644
--- a/heat/tests/aws/test_instance_network.py
+++ b/heat/tests/aws/test_instance_network.py
@@ -204,13 +204,13 @@ class instancesTest(common.HeatTestCase):
                   'SubnetId': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861'}
         tmpl = template.Template(t,
                                  env=environment.Environment(kwargs))
-        stack = parser.Stack(utils.dummy_context(), stack_name, tmpl,
-                             stack_id=str(uuid.uuid4()))
+        self.stack = parser.Stack(utils.dummy_context(), stack_name, tmpl,
+                                  stack_id=str(uuid.uuid4()))
         image_id = 'CentOS 5.2'
         t['Resources']['WebServer']['Properties']['ImageId'] = image_id
-        resource_defns = stack.t.resource_definitions(stack)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         instance = instances.Instance('%s_name' % name,
-                                      resource_defns['WebServer'], stack)
+                                      resource_defns['WebServer'], self.stack)
         metadata = instance.metadata_get()
 
         self.m.StubOutWithMock(nova.NovaClientPlugin, '_create')
@@ -259,18 +259,18 @@ class instancesTest(common.HeatTestCase):
                   'SubnetId': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861'}
         tmpl = template.Template(t,
                                  env=environment.Environment(kwargs))
-        stack = parser.Stack(utils.dummy_context(), stack_name, tmpl,
-                             stack_id=str(uuid.uuid4()))
+        self.stack = parser.Stack(utils.dummy_context(), stack_name, tmpl,
+                                  stack_id=str(uuid.uuid4()))
         image_id = 'CentOS 5.2'
         t['Resources']['WebServer']['Properties']['ImageId'] = image_id
 
-        resource_defns = stack.t.resource_definitions(stack)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         nic = net_interfaces.NetworkInterface('%s_nic' % name,
                                               resource_defns['nic1'],
-                                              stack)
+                                              self.stack)
 
         instance = instances.Instance('%s_name' % name,
-                                      resource_defns['WebServer'], stack)
+                                      resource_defns['WebServer'], self.stack)
         metadata = instance.metadata_get()
 
         self._mock_get_image_id_success(image_id, 1)
@@ -310,7 +310,7 @@ class instancesTest(common.HeatTestCase):
 
         # create network interface
         scheduler.TaskRunner(nic.create)()
-        stack.resources["nic1"] = nic
+        self.stack.resources["nic1"] = nic
 
         scheduler.TaskRunner(instance.create)()
         return instance
diff --git a/heat/tests/aws/test_loadbalancer.py b/heat/tests/aws/test_loadbalancer.py
index 17e3b91104..a36fcd5f78 100644
--- a/heat/tests/aws/test_loadbalancer.py
+++ b/heat/tests/aws/test_loadbalancer.py
@@ -159,11 +159,11 @@ class LoadBalancerTest(common.HeatTestCase):
         if not include_magic:
             del template['Parameters']['KeyName']
             del template['Parameters']['LbFlavor']
-        stack = utils.parse_stack(template)
+        self.stack = utils.parse_stack(template)
 
         resource_name = 'LoadBalancer'
-        lb_defn = stack.t.resource_definitions(stack)[resource_name]
-        return lb.LoadBalancer(resource_name, lb_defn, stack)
+        lb_defn = self.stack.t.resource_definitions(self.stack)[resource_name]
+        return lb.LoadBalancer(resource_name, lb_defn, self.stack)
 
     def test_loadbalancer_refid(self):
         rsrc = self.setup_loadbalancer()
@@ -253,10 +253,10 @@ class LoadBalancerTest(common.HeatTestCase):
 class HaProxyConfigTest(common.HeatTestCase):
     def setUp(self):
         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'
-        lb_defn = stack.t.resource_definitions(stack)[resource_name]
-        self.lb = lb.LoadBalancer(resource_name, lb_defn, stack)
+        lb_defn = self.stack.t.resource_definitions(self.stack)[resource_name]
+        self.lb = lb.LoadBalancer(resource_name, lb_defn, self.stack)
         self.lb.client_plugin = mock.Mock()
 
     def _mock_props(self, props):
diff --git a/heat/tests/aws/test_waitcondition.py b/heat/tests/aws/test_waitcondition.py
index 364097be08..66c4142bef 100644
--- a/heat/tests/aws/test_waitcondition.py
+++ b/heat/tests/aws/test_waitcondition.py
@@ -593,7 +593,8 @@ class WaitConditionUpdateTest(common.HeatTestCase):
         self.m.VerifyAll()
         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',
                          'Status': 'SUCCESS', 'UniqueId': '1'}
         self._handle_signal(wait_condition_handle, test_metadata, 2)
diff --git a/heat/tests/neutron/test_neutron_firewall.py b/heat/tests/neutron/test_neutron_firewall.py
index 45776b851c..7703667196 100644
--- a/heat/tests/neutron/test_neutron_firewall.py
+++ b/heat/tests/neutron/test_neutron_firewall.py
@@ -86,10 +86,10 @@ class FirewallTest(common.HeatTestCase):
         ).AndReturn({'firewall': {'id': '5678'}})
 
         snippet = template_format.parse(firewall_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         return firewall.Firewall(
-            'firewall', resource_defns['firewall'], stack)
+            'firewall', resource_defns['firewall'], self.stack)
 
     def test_create(self):
         rsrc = self.create_firewall()
@@ -214,10 +214,10 @@ class FirewallPolicyTest(common.HeatTestCase):
         ).AndReturn({'firewall_policy': {'id': '5678'}})
 
         snippet = template_format.parse(firewall_policy_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         return firewall.FirewallPolicy(
-            'firewall_policy', resource_defns['firewall_policy'], stack)
+            'firewall_policy', resource_defns['firewall_policy'], self.stack)
 
     def test_create(self):
         rsrc = self.create_firewall_policy()
@@ -340,10 +340,10 @@ class FirewallRuleTest(common.HeatTestCase):
         ).AndReturn({'firewall_rule': {'id': '5678'}})
 
         snippet = template_format.parse(firewall_rule_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         return firewall.FirewallRule(
-            'firewall_rule', resource_defns['firewall_rule'], stack)
+            'firewall_rule', resource_defns['firewall_rule'], self.stack)
 
     def test_create(self):
         rsrc = self.create_firewall_rule()
diff --git a/heat/tests/neutron/test_neutron_loadbalancer.py b/heat/tests/neutron/test_neutron_loadbalancer.py
index d537415175..a42b625fd5 100644
--- a/heat/tests/neutron/test_neutron_loadbalancer.py
+++ b/heat/tests/neutron/test_neutron_loadbalancer.py
@@ -170,10 +170,10 @@ class HealthMonitorTest(common.HeatTestCase):
         ).AndReturn({'health_monitor': {'id': '5678'}})
 
         snippet = template_format.parse(health_monitor_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         return loadbalancer.HealthMonitor(
-            'monitor', resource_defns['monitor'], stack)
+            'monitor', resource_defns['monitor'], self.stack)
 
     def test_create(self):
         rsrc = self.create_health_monitor()
@@ -191,10 +191,10 @@ class HealthMonitorTest(common.HeatTestCase):
         self.m.ReplayAll()
 
         snippet = template_format.parse(health_monitor_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         rsrc = loadbalancer.HealthMonitor(
-            'monitor', resource_defns['monitor'], stack)
+            'monitor', resource_defns['monitor'], self.stack)
         error = self.assertRaises(exception.ResourceFailure,
                                   scheduler.TaskRunner(rsrc.create))
         self.assertEqual(
@@ -344,10 +344,10 @@ class PoolTest(common.HeatTestCase):
             snippet = template_format.parse(pool_template_deprecated)
             neutronclient.Client.create_vip(stvippsn
                                             ).AndReturn({'vip': {'id': 'xyz'}})
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         return loadbalancer.Pool(
-            'pool', resource_defns['pool'], stack)
+            'pool', resource_defns['pool'], self.stack)
 
     def test_create(self):
         self._test_create()
@@ -398,10 +398,10 @@ class PoolTest(common.HeatTestCase):
             {'vip': {'status': 'ACTIVE'}})
 
         snippet = template_format.parse(pool_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         rsrc = loadbalancer.Pool(
-            'pool', resource_defns['pool'], stack)
+            'pool', resource_defns['pool'], self.stack)
         self.m.ReplayAll()
         scheduler.TaskRunner(rsrc.create)()
         self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
@@ -432,10 +432,10 @@ class PoolTest(common.HeatTestCase):
             {'pool': {'status': 'ERROR', 'name': '5678'}})
 
         snippet = template_format.parse(pool_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         rsrc = loadbalancer.Pool(
-            'pool', resource_defns['pool'], stack)
+            'pool', resource_defns['pool'], self.stack)
         self.m.ReplayAll()
         error = self.assertRaises(exception.ResourceFailure,
                                   scheduler.TaskRunner(rsrc.create))
@@ -470,10 +470,10 @@ class PoolTest(common.HeatTestCase):
             {'vip': {'status': 'SOMETHING', 'name': 'xyz'}})
 
         snippet = template_format.parse(pool_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         rsrc = loadbalancer.Pool(
-            'pool', resource_defns['pool'], stack)
+            'pool', resource_defns['pool'], self.stack)
         self.m.ReplayAll()
         error = self.assertRaises(exception.ResourceFailure,
                                   scheduler.TaskRunner(rsrc.create))
@@ -499,10 +499,10 @@ class PoolTest(common.HeatTestCase):
         self.m.ReplayAll()
 
         snippet = template_format.parse(pool_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         rsrc = loadbalancer.Pool(
-            'pool', resource_defns['pool'], stack)
+            'pool', resource_defns['pool'], self.stack)
         error = self.assertRaises(exception.ResourceFailure,
                                   scheduler.TaskRunner(rsrc.create))
         self.assertEqual(
@@ -538,10 +538,10 @@ class PoolTest(common.HeatTestCase):
             {'vip': {'status': 'ACTIVE'}})
 
         snippet = template_format.parse(pool_with_session_persistence_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         rsrc = loadbalancer.Pool(
-            'pool', resource_defns['pool'], stack)
+            'pool', resource_defns['pool'], self.stack)
         self.m.ReplayAll()
         scheduler.TaskRunner(rsrc.create)()
         self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
@@ -558,9 +558,10 @@ class PoolTest(common.HeatTestCase):
         persistence['type'] = 'APP_COOKIE'
         persistence['cookie_name'] = None
 
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
-        resource = loadbalancer.Pool('pool', resource_defns['pool'], stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
+        resource = loadbalancer.Pool('pool', resource_defns['pool'],
+                                     self.stack)
 
         error = self.assertRaises(exception.StackValidationFailed,
                                   resource.validate)
@@ -569,9 +570,10 @@ class PoolTest(common.HeatTestCase):
     def test_validation_not_failing_without_session_persistence(self):
         snippet = template_format.parse(pool_template)
 
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
-        resource = loadbalancer.Pool('pool', resource_defns['pool'], stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
+        resource = loadbalancer.Pool('pool', resource_defns['pool'],
+                                     self.stack)
         self.stub_SubnetConstraint_validate()
         self.m.ReplayAll()
         self.assertIsNone(resource.validate())
@@ -610,9 +612,10 @@ class PoolTest(common.HeatTestCase):
         persistence['type'] = 'HTTP_COOKIE'
         del persistence['cookie_name']
 
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
-        resource = loadbalancer.Pool('pool', resource_defns['pool'], stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
+        resource = loadbalancer.Pool('pool', resource_defns['pool'],
+                                     self.stack)
 
         # assert that properties contain cookie_name property with None value
         persistence = resource.properties['vip']['session_persistence']
@@ -760,11 +763,11 @@ class PoolTest(common.HeatTestCase):
             '5678', {'health_monitor': {'id': 'mon789'}})
 
         snippet = template_format.parse(pool_template)
-        stack = utils.parse_stack(snippet)
+        self.stack = utils.parse_stack(snippet)
         snippet['resources']['pool']['properties']['monitors'] = [
             'mon123', 'mon456']
-        resource_defns = stack.t.resource_definitions(stack)
-        rsrc = loadbalancer.Pool('pool', resource_defns['pool'], stack)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
+        rsrc = loadbalancer.Pool('pool', resource_defns['pool'], self.stack)
         self.m.ReplayAll()
         scheduler.TaskRunner(rsrc.create)()
 
@@ -792,10 +795,10 @@ class PoolMemberTest(common.HeatTestCase):
                 'address': '1.2.3.4', 'admin_state_up': True}}
         ).AndReturn({'member': {'id': 'member5678'}})
         snippet = template_format.parse(member_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         return loadbalancer.PoolMember(
-            'member', resource_defns['member'], stack)
+            'member', resource_defns['member'], self.stack)
 
     def test_create(self):
         rsrc = self.create_member()
@@ -816,10 +819,10 @@ class PoolMemberTest(common.HeatTestCase):
         snippet = template_format.parse(member_template)
         snippet['resources']['member']['properties']['admin_state_up'] = False
         snippet['resources']['member']['properties']['weight'] = 100
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         rsrc = loadbalancer.PoolMember(
-            'member', resource_defns['member'], stack)
+            'member', resource_defns['member'], self.stack)
 
         self.m.ReplayAll()
         scheduler.TaskRunner(rsrc.create)()
@@ -893,10 +896,10 @@ class LoadBalancerTest(common.HeatTestCase):
                 'address': '1.2.3.4'}}
         ).AndReturn({'member': {'id': 'member5678'}})
         snippet = template_format.parse(lb_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         return loadbalancer.LoadBalancer(
-            'lb', resource_defns['lb'], stack)
+            'lb', resource_defns['lb'], self.stack)
 
     def test_create(self):
         rsrc = self.create_load_balancer()
diff --git a/heat/tests/neutron/test_neutron_metering.py b/heat/tests/neutron/test_neutron_metering.py
index 7777394524..352bcdeb0b 100644
--- a/heat/tests/neutron/test_neutron_metering.py
+++ b/heat/tests/neutron/test_neutron_metering.py
@@ -67,10 +67,10 @@ class MeteringLabelTest(common.HeatTestCase):
         }).AndReturn({'metering_label': {'id': '1234'}})
 
         snippet = template_format.parse(metering_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         return metering.MeteringLabel(
-            'label', resource_defns['label'], stack)
+            'label', resource_defns['label'], self.stack)
 
     def test_create(self):
         rsrc = self.create_metering_label()
@@ -180,10 +180,10 @@ class MeteringRuleTest(common.HeatTestCase):
         }).AndReturn({'metering_label_rule': {'id': '5678'}})
 
         snippet = template_format.parse(metering_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         return metering.MeteringRule(
-            'rule', resource_defns['rule'], stack)
+            'rule', resource_defns['rule'], self.stack)
 
     def test_create(self):
         rsrc = self.create_metering_label_rule()
diff --git a/heat/tests/neutron/test_neutron_network_gateway.py b/heat/tests/neutron/test_neutron_network_gateway.py
index 05eaeab145..9ec8cdb523 100644
--- a/heat/tests/neutron/test_neutron_network_gateway.py
+++ b/heat/tests/neutron/test_neutron_network_gateway.py
@@ -129,11 +129,11 @@ class NeutronNetworkGatewayTest(common.HeatTestCase):
 
         t = template_format.parse(gw_template)
 
-        stack = utils.parse_stack(t)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(t)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         rsrc = network_gateway.NetworkGateway(
             'test_network_gateway',
-            resource_defns['NetworkGateway'], stack)
+            resource_defns['NetworkGateway'], self.stack)
         return rsrc
 
     def prepare_create_network_gateway(self, resolve_neutron=True):
@@ -180,11 +180,11 @@ class NeutronNetworkGatewayTest(common.HeatTestCase):
         else:
             t = template_format.parse(gw_template_deprecated)
 
-        stack = utils.parse_stack(t)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(t)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         rsrc = network_gateway.NetworkGateway(
             'test_network_gateway',
-            resource_defns['NetworkGateway'], stack)
+            resource_defns['NetworkGateway'], self.stack)
         return rsrc
 
     def _test_network_gateway_create(self, resolve_neutron=True):
diff --git a/heat/tests/neutron/test_neutron_provider_net.py b/heat/tests/neutron/test_neutron_provider_net.py
index f440c1dbcb..95f51288ec 100644
--- a/heat/tests/neutron/test_neutron_provider_net.py
+++ b/heat/tests/neutron/test_neutron_provider_net.py
@@ -88,10 +88,11 @@ class NeutronProviderNetTest(common.HeatTestCase):
         ).AndReturn(stpna)
 
         t = template_format.parse(provider_network_template)
-        stack = utils.parse_stack(t)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(t)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         rsrc = provider_net.ProviderNet(
-            'provider_net', resource_defns['provider_network_vlan'], stack)
+            'provider_net', resource_defns['provider_network_vlan'],
+            self.stack)
 
         return rsrc
 
diff --git a/heat/tests/test_ceilometer_alarm.py b/heat/tests/test_ceilometer_alarm.py
index 8b50bb7822..cf0f91154f 100644
--- a/heat/tests/test_ceilometer_alarm.py
+++ b/heat/tests/test_ceilometer_alarm.py
@@ -441,8 +441,8 @@ class CeilometerAlarmTest(common.HeatTestCase):
 
     def _prepare_check_resource(self):
         snippet = template_format.parse(not_string_alarm_template)
-        stack = utils.parse_stack(snippet)
-        res = stack['MEMAlarmHigh']
+        self.stack = utils.parse_stack(snippet)
+        res = self.stack['MEMAlarmHigh']
         res.ceilometer = mock.Mock()
         mock_alarm = mock.Mock(enabled=True, state='ok')
         res.ceilometer().alarms.get.return_value = mock_alarm
@@ -499,10 +499,10 @@ class CombinationAlarmTest(common.HeatTestCase):
                               'operator': u'and'}
         ).AndReturn(FakeCeilometerAlarm())
         snippet = template_format.parse(combination_alarm_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         return alarm.CombinationAlarm(
-            'CombinAlarm', resource_defns['CombinAlarm'], stack)
+            'CombinAlarm', resource_defns['CombinAlarm'], self.stack)
 
     def test_create(self):
         rsrc = self.create_alarm()
@@ -596,8 +596,8 @@ class CombinationAlarmTest(common.HeatTestCase):
 
     def _prepare_check_resource(self):
         snippet = template_format.parse(combination_alarm_template)
-        stack = utils.parse_stack(snippet)
-        res = stack['CombinAlarm']
+        self.stack = utils.parse_stack(snippet)
+        res = self.stack['CombinAlarm']
         res.ceilometer = mock.Mock()
         mock_alarm = mock.Mock(enabled=True, state='ok')
         res.ceilometer().alarms.get.return_value = mock_alarm
diff --git a/heat/tests/test_instance_group.py b/heat/tests/test_instance_group.py
index 5495bbd815..cc36f7c5e2 100644
--- a/heat/tests/test_instance_group.py
+++ b/heat/tests/test_instance_group.py
@@ -34,13 +34,13 @@ class TestInstanceGroup(common.HeatTestCase):
     def setUp(self):
         super(TestInstanceGroup, self).setUp()
         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(
             'asg', 'OS::Heat::InstanceGroup',
             {'Size': 2, 'AvailabilityZones': ['zoneb'],
              'LaunchConfigurationName': 'config'})
         self.instance_group = instgrp.InstanceGroup('asg',
-                                                    self.defn, stack)
+                                                    self.defn, self.stack)
 
     def test_child_template(self):
         self.instance_group._create_template = mock.Mock(return_value='tpl')
@@ -327,14 +327,14 @@ class ReplaceTest(common.HeatTestCase):
         resource._register_class('ResourceWithPropsAndAttrs',
                                  generic_resource.ResourceWithPropsAndAttrs)
         t = template_format.parse(inline_templates.as_template)
-        stack = utils.parse_stack(t, params=inline_templates.as_params)
-        lc = self.create_launch_config(t, stack)
+        self.stack = utils.parse_stack(t, params=inline_templates.as_params)
+        lc = self.create_launch_config(t, self.stack)
         lcid = lc.FnGetRefId()
         self.defn = rsrc_defn.ResourceDefinition(
             'asg', 'OS::Heat::InstanceGroup',
             {'Size': 2, 'AvailabilityZones': ['zoneb'],
              '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.update_with_template = mock.Mock()
diff --git a/heat/tests/test_nested_stack.py b/heat/tests/test_nested_stack.py
index b0c08aed03..ea31bd777e 100644
--- a/heat/tests/test_nested_stack.py
+++ b/heat/tests/test_nested_stack.py
@@ -311,9 +311,9 @@ Outputs:
 
         self.ctx = utils.dummy_context('test_username', 'aaaa', 'password')
         empty_template = {"HeatTemplateFormatVersion": "2012-12-12"}
-        stack = parser.Stack(self.ctx, 'test',
-                             template.Template(empty_template))
-        stack.store()
+        self.stack = parser.Stack(self.ctx, 'test',
+                                  template.Template(empty_template))
+        self.stack.store()
 
         self.patchobject(urlfetch, 'get', return_value=self.nested_template)
         self.nested_parsed = yaml.load(self.nested_template)
@@ -324,7 +324,7 @@ Outputs:
             {"TemplateURL": "https://server.test/the.template",
              "Parameters": self.nested_params})
         self.res = stack_res.NestedStack('test_t_res',
-                                         self.defn, stack)
+                                         self.defn, self.stack)
         self.assertIsNone(self.res.validate())
         self.res._store()
 
diff --git a/heat/tests/test_nova_floatingip.py b/heat/tests/test_nova_floatingip.py
index 4be0cac67d..49f6c7f217 100644
--- a/heat/tests/test_nova_floatingip.py
+++ b/heat/tests/test_nova_floatingip.py
@@ -89,12 +89,12 @@ class NovaFloatingIPTest(common.HeatTestCase):
         )
 
         template = template_format.parse(floating_ip_template)
-        stack = utils.parse_stack(template)
-        floating_ip = stack.t.resource_definitions(stack)['MyFloatingIP']
+        self.stack = utils.parse_stack(template)
+        defns = self.stack.t.resource_definitions(self.stack)
 
         return nova_floatingip.NovaFloatingIp('MyFloatingIP',
-                                              floating_ip,
-                                              stack)
+                                              defns['MyFloatingIP'],
+                                              self.stack)
 
     def prepare_floating_ip_assoc(self):
         nova.NovaClientPlugin._create().AndReturn(
@@ -109,12 +109,12 @@ class NovaFloatingIPTest(common.HeatTestCase):
         )
 
         template = template_format.parse(floating_ip_template_with_assoc)
-        stack = utils.parse_stack(template)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(template)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         floating_ip_assoc = resource_defns['MyFloatingIPAssociation']
 
         return nova_floatingip.NovaFloatingIpAssociation(
-            'MyFloatingIPAssociation', floating_ip_assoc, stack)
+            'MyFloatingIPAssociation', floating_ip_assoc, self.stack)
 
     def test_floating_ip_create(self):
         rsrc = self.prepare_floating_ip()
diff --git a/heat/tests/test_nova_keypair.py b/heat/tests/test_nova_keypair.py
index c0a1bacfa4..e625ad34a2 100644
--- a/heat/tests/test_nova_keypair.py
+++ b/heat/tests/test_nova_keypair.py
@@ -56,9 +56,9 @@ class NovaKeyPairTest(common.HeatTestCase):
         return mkey
 
     def _get_test_resource(self, template):
-        stack = utils.parse_stack(template)
-        definition = stack.t.resource_definitions(stack)['kp']
-        kp_res = nova_keypair.KeyPair('kp', definition, stack)
+        self.stack = utils.parse_stack(template)
+        definition = self.stack.t.resource_definitions(self.stack)['kp']
+        kp_res = nova_keypair.KeyPair('kp', definition, self.stack)
         self.m.StubOutWithMock(nova.NovaClientPlugin, '_create')
         nova.NovaClientPlugin._create().AndReturn(self.fake_nova)
         return kp_res
diff --git a/heat/tests/test_nova_servergroup.py b/heat/tests/test_nova_servergroup.py
index 45dcd2ad81..def6833b69 100644
--- a/heat/tests/test_nova_servergroup.py
+++ b/heat/tests/test_nova_servergroup.py
@@ -47,8 +47,8 @@ class NovaServerGroupTest(common.HeatTestCase):
 
     def _init_template(self, sg_template):
         template = template_format.parse(json.dumps(sg_template))
-        stack = utils.parse_stack(template)
-        self.sg = stack['ServerGroup']
+        self.stack = utils.parse_stack(template)
+        self.sg = self.stack['ServerGroup']
         # create mock clients and objects
         nova = mock.MagicMock()
         self.sg.nova = mock.MagicMock(return_value=nova)
@@ -56,24 +56,24 @@ class NovaServerGroupTest(common.HeatTestCase):
 
     def _create_sg(self, name):
         if name:
-                sg = sg_template['resources']['ServerGroup']
-                sg['properties']['name'] = name
-                self._init_template(sg_template)
-                self.sg_mgr.create.return_value = FakeGroup(name)
+            sg = sg_template['resources']['ServerGroup']
+            sg['properties']['name'] = name
+            self._init_template(sg_template)
+            self.sg_mgr.create.return_value = FakeGroup(name)
         else:
-                try:
-                        sg = sg_template['resources']['ServerGroup']
-                        del sg['properties']['name']
-                except Exception:
-                        pass
-                self._init_template(sg_template)
-                name = 'test'
-                n = name
+            try:
+                sg = sg_template['resources']['ServerGroup']
+                del sg['properties']['name']
+            except Exception:
+                pass
+            self._init_template(sg_template)
+            name = 'test'
+            n = name
 
-                def fake_create(name, policies):
-                        self.assertTrue(len(name) > 1)
-                        return FakeGroup(n)
-                self.sg_mgr.create = fake_create
+            def fake_create(name, policies):
+                self.assertTrue(len(name) > 1)
+                return FakeGroup(n)
+            self.sg_mgr.create = fake_create
         scheduler.TaskRunner(self.sg.create)()
         self.assertEqual((self.sg.CREATE, self.sg.COMPLETE),
                          self.sg.state)
diff --git a/heat/tests/test_os_database.py b/heat/tests/test_os_database.py
index cf50268998..9cc11d72e2 100644
--- a/heat/tests/test_os_database.py
+++ b/heat/tests/test_os_database.py
@@ -107,15 +107,15 @@ class OSDBInstanceTest(common.HeatTestCase):
     def _setup_test_clouddbinstance(self, name, t):
         stack_name = '%s_stack' % name
         template = tmpl.Template(t)
-        stack = parser.Stack(utils.dummy_context(),
-                             stack_name,
-                             template,
-                             stack_id=str(uuid.uuid4()))
+        self.stack = parser.Stack(utils.dummy_context(),
+                                  stack_name,
+                                  template,
+                                  stack_id=str(uuid.uuid4()))
 
         instance = os_database.OSDBInstance(
             '%s_name' % name,
-            template.resource_definitions(stack)['MySqlCloudDB'],
-            stack)
+            template.resource_definitions(self.stack)['MySqlCloudDB'],
+            self.stack)
         return instance
 
     def _stubout_common_create(self):
diff --git a/heat/tests/test_properties.py b/heat/tests/test_properties.py
index b5dc7fc732..66b0882f46 100644
--- a/heat/tests/test_properties.py
+++ b/heat/tests/test_properties.py
@@ -1102,7 +1102,10 @@ class PropertiesTest(common.HeatTestCase):
         class rsrc(object):
             action = INIT = "INIT"
 
-        stack = {'another_res': rsrc()}
+        class DummyStack(dict):
+            pass
+
+        stack = DummyStack(another_res=rsrc())
 
         # define properties with function and constraint
         props = properties.Properties(
diff --git a/heat/tests/test_provider_template.py b/heat/tests/test_provider_template.py
index 168eb5ee31..64fa0d08e4 100644
--- a/heat/tests/test_provider_template.py
+++ b/heat/tests/test_provider_template.py
@@ -838,16 +838,17 @@ class TemplateResourceCrudTest(common.HeatTestCase):
         resource._register_class('DummyResource', DummyResource)
         env.load({'resource_registry':
                   {'DummyResource': 'test_resource.template'}})
-        stack = parser.Stack(self.ctx, 'test_stack',
-                             template.Template(empty_template, files=files,
-                                               env=env),
-                             stack_id=str(uuid.uuid4()))
+        self.stack = parser.Stack(self.ctx, 'test_stack',
+                                  template.Template(empty_template,
+                                                    files=files,
+                                                    env=env),
+                                  stack_id=str(uuid.uuid4()))
 
         self.defn = rsrc_defn.ResourceDefinition('test_t_res',
                                                  "DummyResource",
                                                  {"Foo": "bar"})
         self.res = template_resource.TemplateResource('test_t_res',
-                                                      self.defn, stack)
+                                                      self.defn, self.stack)
         self.assertIsNone(self.res.validate())
 
     def test_handle_create(self):
diff --git a/heat/tests/test_restarter.py b/heat/tests/test_restarter.py
index e9e61a6cc9..cc1a9025bb 100644
--- a/heat/tests/test_restarter.py
+++ b/heat/tests/test_restarter.py
@@ -45,10 +45,10 @@ class RestarterTest(common.HeatTestCase):
 
     def create_restarter(self):
         snippet = template_format.parse(restarter_template)
-        stack = utils.parse_stack(snippet)
-        resource_defns = stack.t.resource_definitions(stack)
+        self.stack = utils.parse_stack(snippet)
+        resource_defns = self.stack.t.resource_definitions(self.stack)
         restarter = ha_restarter.Restarter(
-            'restarter', resource_defns['restarter'], stack)
+            'restarter', resource_defns['restarter'], self.stack)
         nova.NovaClientPlugin.get_server = mock.Mock(
             return_value=mock.MagicMock())
         restarter.handle_create = mock.Mock(return_value=None)
diff --git a/heat/tests/test_sahara_cluster.py b/heat/tests/test_sahara_cluster.py
index 93b8fdab8f..7c9ddf2c72 100644
--- a/heat/tests/test_sahara_cluster.py
+++ b/heat/tests/test_sahara_cluster.py
@@ -73,8 +73,8 @@ class SaharaClusterTest(common.HeatTestCase):
         self.t = template_format.parse(cluster_stack_template)
 
     def _init_cluster(self, template):
-        stack = utils.parse_stack(template)
-        cluster = stack['super-cluster']
+        self.stack = utils.parse_stack(template)
+        cluster = self.stack['super-cluster']
         return cluster
 
     def _create_cluster(self, template):
diff --git a/heat/tests/test_sahara_templates.py b/heat/tests/test_sahara_templates.py
index f934beae09..8fdddc970e 100644
--- a/heat/tests/test_sahara_templates.py
+++ b/heat/tests/test_sahara_templates.py
@@ -89,8 +89,8 @@ class SaharaNodeGroupTemplateTest(common.HeatTestCase):
         self.t = template_format.parse(node_group_template)
 
     def _init_ngt(self, template):
-        stack = utils.parse_stack(template)
-        return stack['node-group']
+        self.stack = utils.parse_stack(template)
+        return self.stack['node-group']
 
     def test_ngt_resource_mapping(self):
         ngt = self._init_ngt(self.t)
@@ -211,8 +211,8 @@ class SaharaClusterTemplateTest(common.HeatTestCase):
         self.t = template_format.parse(cluster_template)
 
     def _init_ct(self, template):
-        stack = utils.parse_stack(template)
-        return stack['cluster-template']
+        self.stack = utils.parse_stack(template)
+        return self.stack['cluster-template']
 
     def test_ct_resource_mapping(self):
         ct = self._init_ct(self.t)
diff --git a/heat/tests/test_server.py b/heat/tests/test_server.py
index e3b0f6097f..1104881082 100644
--- a/heat/tests/test_server.py
+++ b/heat/tests/test_server.py
@@ -127,9 +127,9 @@ class ServersTest(common.HeatTestCase):
         return (templ, stack)
 
     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]
-        res = stack['WebServer']
+        res = self.stack['WebServer']
         res.nova = mock.Mock()
         res.nova().servers.get = mock.Mock(return_value=server)
         return res
@@ -183,11 +183,11 @@ class ServersTest(common.HeatTestCase):
                            server_rebuild=False):
         stack_name = '%s_s' % name
         server_name = str(name) if override_name else None
-        tmpl, stack = self._get_test_template(stack_name, server_name,
-                                              image_id)
-        resource_defns = tmpl.resource_definitions(stack)
+        tmpl, self.stack = self._get_test_template(stack_name, server_name,
+                                                   image_id)
+        resource_defns = tmpl.resource_definitions(self.stack)
         server = servers.Server(str(name), resource_defns['WebServer'],
-                                stack)
+                                self.stack)
 
         self._mock_get_image_id_success(image_id or 'CentOS 5.2', 1,
                                         server_rebuild=server_rebuild)
diff --git a/heat/tests/test_server_tags.py b/heat/tests/test_server_tags.py
index 67630c9a60..ebea601647 100644
--- a/heat/tests/test_server_tags.py
+++ b/heat/tests/test_server_tags.py
@@ -69,13 +69,13 @@ class ServerTagsTest(common.HeatTestCase):
         template = tmpl.Template(t,
                                  env=environment.Environment(
                                      {'KeyName': 'test'}))
-        stack = parser.Stack(utils.dummy_context(), stack_name, template,
-                             stack_id=str(uuid.uuid4()))
+        self.stack = parser.Stack(utils.dummy_context(), stack_name, template,
+                                  stack_id=str(uuid.uuid4()))
 
         t['Resources']['WebServer']['Properties']['Tags'] = intags
-        resource_defns = template.resource_definitions(stack)
+        resource_defns = template.resource_definitions(self.stack)
         instance = instances.Instance(stack_name,
-                                      resource_defns['WebServer'], stack)
+                                      resource_defns['WebServer'], self.stack)
 
         self.m.StubOutWithMock(nova.NovaClientPlugin, '_create')
         nova.NovaClientPlugin._create().AndReturn(self.fc)
diff --git a/heat/tests/test_stack_user.py b/heat/tests/test_stack_user.py
index 21a794bea5..ee89dc0b47 100644
--- a/heat/tests/test_stack_user.py
+++ b/heat/tests/test_stack_user.py
@@ -48,8 +48,8 @@ class StackUserTest(common.HeatTestCase):
                      resource_name='user', create_project=True,
                      password=None):
         t = template_format.parse(user_template)
-        stack = utils.parse_stack(t, stack_name=stack_name)
-        rsrc = stack[resource_name]
+        self.stack = utils.parse_stack(t, stack_name=stack_name)
+        rsrc = self.stack[resource_name]
 
         self.m.StubOutWithMock(stack_user.StackUser, 'keystone')
         stack_user.StackUser.keystone().MultipleTimes().AndReturn(self.fc)
@@ -58,9 +58,9 @@ class StackUserTest(common.HeatTestCase):
             self.m.StubOutWithMock(fakes.FakeKeystoneClient,
                                    'create_stack_domain_project')
             fakes.FakeKeystoneClient.create_stack_domain_project(
-                stack.id).AndReturn(project_id)
+                self.stack.id).AndReturn(project_id)
         else:
-            stack.set_stack_user_project_id(project_id)
+            self.stack.set_stack_user_project_id(project_id)
 
         rsrc._store()
         self.m.StubOutWithMock(short_id, 'get_id')
diff --git a/heat/tests/test_swift.py b/heat/tests/test_swift.py
index 5623a7b56e..05e4027b67 100644
--- a/heat/tests/test_swift.py
+++ b/heat/tests/test_swift.py
@@ -363,8 +363,8 @@ class swiftTest(common.HeatTestCase):
 
     def _get_check_resource(self):
         t = template_format.parse(swift_template)
-        stack = utils.parse_stack(t)
-        res = self.create_resource(t, stack, 'SwiftContainer')
+        self.stack = utils.parse_stack(t)
+        res = self.create_resource(t, self.stack, 'SwiftContainer')
         res.swift = mock.Mock()
         return res