Merge "Removing default version for templates"

heat/engine/resources/autoscaling.py

@@ -301,7 +301,8 @@ class InstanceGroup(stack_resource.StackResource):
         old_resources = self._get_instance_templates()
         templates = template.resource_templates(
             old_resources, instance_definition, num_instances, num_replace)
-        return {"Resources": dict(templates)}
+        return {"HeatTemplateFormatVersion": "2012-12-12",
+                "Resources": dict(templates)}
 
     def _try_rolling_update(self, prop_diff):
         if (self.update_policy[self.ROLLING_UPDATE] and
@@ -958,6 +959,7 @@ class AutoScalingResourceGroup(AutoScalingGroup):
         """Use a HOT format for the template in the nested stack."""
         tpl = super(AutoScalingResourceGroup, self)._create_template(
             *args, **kwargs)
+        tpl.pop('HeatTemplateFormatVersion', None)
         tpl['heat_template_version'] = '2013-05-23'
         tpl['resources'] = tpl.pop('Resources')
         return tpl

heat/engine/resources/template_resource.py

@@ -86,7 +86,8 @@ class TemplateResource(stack_resource.StackResource):
             tmpl = template.Template(self.child_template())
         except ValueError as download_error:
             self.validation_exception = download_error
-            tmpl = template.Template({})
+            tmpl = template.Template(
+                {"HeatTemplateFormatVersion": "2012-12-12"})
 
         # re-generate the properties and attributes from the template.
         self.properties_schema = (properties.Properties

heat/engine/template.py

@@ -25,8 +25,6 @@ logger = logging.getLogger(__name__)
 __all__ = ['Template']
 
 
-DEFAULT_VERSION = ('HeatTemplateFormatVersion', '2012-12-12')
-
 _template_classes = None
 
 
@@ -61,14 +59,15 @@ def get_version(template_data, available_versions):
                          isinstance(v, basestring))
 
     keys_present = version_keys & candidate_keys
-    if not keys_present:
-        return DEFAULT_VERSION
 
     if len(keys_present) > 1:
         explanation = _('Ambiguous versions (%s)') % ', '.join(keys_present)
         raise exception.InvalidTemplateVersion(explanation=explanation)
-
+    try:
-    version_key = keys_present.pop()
+        version_key = keys_present.pop()
+    except KeyError:
+        explanation = _('Template version was not provided')
+        raise exception.InvalidTemplateVersion(explanation=explanation)
     return version_key, template_data[version_key]
 
 

heat/tests/test_cloud_config.py

@@ -33,6 +33,7 @@ class CloudConfigTest(HeatTestCase):
         self.stack = parser.Stack(
             self.ctx, 'software_config_test_stack',
             template.Template({
+                'HeatTemplateFormatVersion': '2012-12-12',
                 'Resources': {
                     'config_mysql': {
                         'Type': 'OS::Heat::CloudConfig',

heat/tests/test_engine_api_utils.py

@@ -34,6 +34,7 @@ class FormatTest(HeatTestCase):
         super(FormatTest, self).setUp()
 
         template = parser.Template({
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Resources': {
                 'generic1': {'Type': 'GenericResourceType'},
                 'generic2': {

heat/tests/test_engine_service.py

@@ -494,7 +494,7 @@ class StackServiceCreateUpdateDeleteTest(HeatTestCase):
 
         self.assertRaises(ValueError,
                           self.man.create_stack,
-                          self.ctx, stack_name, stack.t, {}, None, {})
+                          self.ctx, stack_name, stack.t.t, {}, None, {})
 
     def test_stack_create_invalid_resource_name(self):
         stack_name = 'service_create_test_stack_invalid_res'
@@ -506,7 +506,7 @@ class StackServiceCreateUpdateDeleteTest(HeatTestCase):
         self.assertRaises(ValueError,
                           self.man.create_stack,
                           self.ctx, stack_name,
-                          stack.t, {}, None, {})
+                          stack.t.t, {}, None, {})
 
     def test_stack_create_no_credentials(self):
         stack_name = 'test_stack_create_no_credentials'
@@ -557,7 +557,8 @@ class StackServiceCreateUpdateDeleteTest(HeatTestCase):
         params = {}
         res._register_class('GenericResourceType',
                             generic_rsrc.GenericResource)
-        tpl = {'Resources': {
+        tpl = {'HeatTemplateFormatVersion': '2012-12-12',
+               'Resources': {
                'A': {'Type': 'GenericResourceType'},
                'B': {'Type': 'GenericResourceType'},
                'C': {'Type': 'GenericResourceType'}}}
@@ -593,15 +594,15 @@ class StackServiceCreateUpdateDeleteTest(HeatTestCase):
         params = {}
         res._register_class('GenericResourceType',
                             generic_rsrc.GenericResource)
-        tpl = {'Resources': {
+        tpl = {'HeatTemplateFormatVersion': '2012-12-12',
+               'Resources': {
                'A': {'Type': 'GenericResourceType'},
                'B': {'Type': 'GenericResourceType'},
                'C': {'Type': 'GenericResourceType'}}}
-        template = parser.Template(tpl)
         cfg.CONF.set_override('max_resources_per_stack', 2)
         ex = self.assertRaises(rpc_common.ClientException,
                                self.man.create_stack, self.ctx, stack_name,
-                               template, params, None, {})
+                               tpl, params, None, {})
         self.assertEqual(ex._exc_info[0], exception.RequestLimitExceeded)
         self.assertIn(exception.StackResourceLimitExceeded.msg_fmt,
                       str(ex._exc_info[1]))
@@ -862,7 +863,8 @@ class StackServiceCreateUpdateDeleteTest(HeatTestCase):
         params = {}
         res._register_class('GenericResourceType',
                             generic_rsrc.GenericResource)
-        tpl = {'Resources': {
+        tpl = {'HeatTemplateFormatVersion': '2012-12-12',
+               'Resources': {
                'A': {'Type': 'GenericResourceType'},
                'B': {'Type': 'GenericResourceType'},
                'C': {'Type': 'GenericResourceType'}}}
@@ -1046,13 +1048,13 @@ class StackServiceCreateUpdateDeleteTest(HeatTestCase):
         params = {}
         res._register_class('GenericResourceType',
                             generic_rsrc.GenericResource)
-        tpl = {'Resources': {
+        tpl = {'HeatTemplateFormatVersion': '2012-12-12',
+               'Resources': {
                'A': {'Type': 'GenericResourceType'},
                'B': {'Type': 'GenericResourceType'},
                'C': {'Type': 'GenericResourceType'}}}
 
         template = parser.Template(tpl)
-
         old_stack = parser.Stack(self.ctx, stack_name, template)
         sid = old_stack.store()
         self.assertIsNotNone(sid)
@@ -1061,7 +1063,7 @@ class StackServiceCreateUpdateDeleteTest(HeatTestCase):
 
         ex = self.assertRaises(rpc_common.ClientException,
                                self.man.update_stack, self.ctx,
-                               old_stack.identifier(), template, params,
+                               old_stack.identifier(), tpl, params,
                                None, {})
         self.assertEqual(ex._exc_info[0], exception.RequestLimitExceeded)
         self.assertIn(exception.StackResourceLimitExceeded.msg_fmt,
@@ -1507,7 +1509,7 @@ class StackServiceTest(HeatTestCase):
     def test_stack_create_existing(self):
         ex = self.assertRaises(rpc_common.ClientException,
                                self.eng.create_stack, self.ctx,
-                               self.stack.name, self.stack.t, {}, None, {})
+                               self.stack.name, self.stack.t.t, {}, None, {})
         self.assertEqual(ex._exc_info[0], exception.StackExists)
 
     @stack_context('service_name_tenants_test_stack', False)
@@ -1581,7 +1583,8 @@ class StackServiceTest(HeatTestCase):
             return thread
         self.eng.thread_group_mgr.start = run
 
-        new_tmpl = {'Resources': {'AResource': {'Type':
+        new_tmpl = {'HeatTemplateFormatVersion': '2012-12-12',
+                    'Resources': {'AResource': {'Type':
                                                 'GenericResourceType'}}}
 
         self.m.StubOutWithMock(instances.Instance, 'handle_delete')
@@ -2570,6 +2573,7 @@ class StackServiceTest(HeatTestCase):
                             generic_rsrc.GenericResource)
 
         lazy_load_template = {
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Resources': {
                 'foo': {'Type': 'GenericResourceType'},
                 'bar': {
@@ -2607,13 +2611,11 @@ class StackServiceTest(HeatTestCase):
         params = {}
         files = None
         stack_name = 'SampleStack'
-        tpl = {
+        tpl = {'HeatTemplateFormatVersion': '2012-12-12',
-            'Description': 'Lorem ipsum.',
+               'Description': 'Lorem ipsum.',
-            'Resources': {
+               'Resources': {
-                'SampleResource1': {'Type': 'GenericResource1'},
+                   'SampleResource1': {'Type': 'GenericResource1'},
-                'SampleResource2': {'Type': 'GenericResource2'},
+                   'SampleResource2': {'Type': 'GenericResource2'}}}
-            }
-        }
 
         return self.eng.preview_stack(self.ctx, stack_name, tpl,
                                       params, files, args)
@@ -2669,14 +2671,16 @@ class StackServiceTest(HeatTestCase):
     def test_validate_new_stack_checks_stack_limit(self, mock_db_count):
         cfg.CONF.set_override('max_stacks_per_tenant', 99)
         mock_db_count.return_value = 99
-        template = service.parser.Template({})
+        template = service.parser.Template(
+            {'HeatTemplateFormatVersion': '2012-12-12'})
         self.assertRaises(exception.RequestLimitExceeded,
                           self.eng._validate_new_stack,
                           self.ctx, 'test_existing_stack', template)
 
     def test_validate_new_stack_checks_resource_limit(self):
         cfg.CONF.set_override('max_resources_per_stack', 5)
-        template = {'Resources': [1, 2, 3, 4, 5, 6]}
+        template = {'HeatTemplateFormatVersion': '2012-12-12',
+                    'Resources': [1, 2, 3, 4, 5, 6]}
         parsed_template = service.parser.Template(template)
         self.assertRaises(exception.RequestLimitExceeded,
                           self.eng._validate_new_stack,

heat/tests/test_event.py

@@ -26,6 +26,7 @@ cfg.CONF.import_opt('event_purge_batch_size', 'heat.common.config')
 cfg.CONF.import_opt('max_events_per_stack', 'heat.common.config')
 
 tmpl = {
+    'HeatTemplateFormatVersion': '2012-12-12',
     'Resources': {
         'EventTestResource': {
             'Type': 'ResourceWithRequiredProps',
@@ -144,7 +145,8 @@ class EventTest(HeatTestCase):
         self.assertIsNone(e.identifier())
 
     def test_badprop(self):
-        tmpl = {'Type': 'ResourceWithRequiredProps',
+        tmpl = {'HeatTemplateFormatVersion': '2012-12-12',
+                'Type': 'ResourceWithRequiredProps',
                 'Properties': {'Foo': False}}
         rname = 'bad_resource'
         res = generic_rsrc.ResourceWithRequiredProps(rname, tmpl, self.stack)

heat/tests/test_hot.py

@@ -561,7 +561,7 @@ class HOTemplateTest(HeatTestCase):
                              'UpdatePolicy': {"blarg": "wibble"}}
         parent_resource.stack = parser.Stack(utils.dummy_context(),
                                              'toplevel_stack',
-                                             parser.Template({}))
+                                             parser.Template(hot_tpl_empty))
         stack = parser.Stack(utils.dummy_context(), 'test_stack',
                              parser.Template(hot_tpl_empty),
                              parent_resource=parent_resource)
@@ -579,7 +579,7 @@ class HOTemplateTest(HeatTestCase):
         parent_resource.metadata_set({"foo": "bar"})
         parent_resource.stack = parser.Stack(utils.dummy_context(),
                                              'toplevel_stack',
-                                             parser.Template({}))
+                                             parser.Template(hot_tpl_empty))
         parent_snippet = {'DeletionPolicy': {'Fn::Join': ['eta',
                                                           ['R', 'in']]}}
         parent_tmpl = parent_resource.stack.t.parse(parent_resource.stack,
@@ -610,7 +610,7 @@ class HOTemplateTest(HeatTestCase):
         parent_resource.t = {}
         parent_resource.stack = parser.Stack(utils.dummy_context(),
                                              'toplevel_stack',
-                                             parser.Template({}))
+                                             parser.Template(hot_tpl_empty))
         stack = parser.Stack(utils.dummy_context(), 'test_stack',
                              parser.Template(hot_tpl_empty),
                              parent_resource=parent_resource)

heat/tests/test_multi_part.py

@@ -35,6 +35,7 @@ class MultipartMimeTest(HeatTestCase):
         stack = parser.Stack(
             self.ctx, 'software_config_test_stack',
             template.Template({
+                'HeatTemplateFormatVersion': '2012-12-12',
                 'Resources': {
                     'config_mysql': {
                         'Type': 'OS::Heat::MultipartMime',

heat/tests/test_notifications.py

@@ -53,7 +53,8 @@ class NotificationTest(common.HeatTestCase):
                                  generic_resource.ResourceWithProps)
 
     def create_test_stack(self):
-        test_template = {'Parameters': {'Foo': {'Type': 'String'},
+        test_template = {'HeatTemplateFormatVersion': '2012-12-12',
+                         'Parameters': {'Foo': {'Type': 'String'},
                                         'Pass': {'Type': 'String',
                                                  'NoEcho': True}},
                          'Resources':

heat/tests/test_parameters.py

@@ -26,7 +26,8 @@ class ParameterTest(testtools.TestCase):
 
     def new_parameter(self, name, schema, value=None,
                       validate_value=True):
-        tmpl = template.Template({'Parameters': {name: schema}})
+        tmpl = template.Template({'HeatTemplateFormatVersion': '2012-12-12',
+                                  'Parameters': {name: schema}})
         schema = tmpl.param_schemata()[name]
         return parameters.Parameter(name, schema, value,
                                     validate_value)
@@ -310,6 +311,7 @@ params_schema = json.loads('''{
 class ParametersTest(testtools.TestCase):
     def new_parameters(self, stack_name, tmpl, user_params={}, stack_id=None,
                        validate_value=True):
+        tmpl.update({'HeatTemplateFormatVersion': '2012-12-12'})
         tmpl = template.Template(tmpl)
         return tmpl.parameters(
             identifier.HeatIdentifier('', stack_name, stack_id),

heat/tests/test_provider_template.py

@@ -31,6 +31,9 @@ from heat.tests import generic_resource as generic_rsrc
 from heat.tests import utils
 
 
+empty_template = {"HeatTemplateFormatVersion": "2012-12-12"}
+
+
 class MyCloudResource(generic_rsrc.GenericResource):
     pass
 
@@ -115,7 +118,8 @@ class ProviderTemplateTest(HeatTestCase):
         env.load({'resource_registry':
                   {'DummyResource': 'test_resource.template'}})
         stack = parser.Stack(utils.dummy_context(), 'test_stack',
-                             parser.Template({}, files=files), env=env,
+                             parser.Template(empty_template, files=files),
+                             env=env,
                              stack_id=str(uuid.uuid4()))
 
         map_prop_val = {
@@ -174,7 +178,8 @@ class ProviderTemplateTest(HeatTestCase):
         env.load({'resource_registry':
                   {'DummyResource': 'test_resource.template'}})
         stack = parser.Stack(utils.dummy_context(), 'test_stack',
-                             parser.Template({}, files=files), env=env,
+                             parser.Template(empty_template, files=files),
+                             env=env,
                              stack_id=str(uuid.uuid4()))
 
         json_snippet = {
@@ -187,6 +192,7 @@ class ProviderTemplateTest(HeatTestCase):
 
     def test_attributes_missing(self):
         provider = {
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Outputs': {
                 'Blarg': {'Value': 'wibble'},
             },
@@ -206,7 +212,8 @@ class ProviderTemplateTest(HeatTestCase):
         env.load({'resource_registry':
                   {'DummyResource': 'test_resource.template'}})
         stack = parser.Stack(utils.dummy_context(), 'test_stack',
-                             parser.Template({}, files=files), env=env,
+                             parser.Template(empty_template, files=files),
+                             env=env,
                              stack_id=str(uuid.uuid4()))
 
         temp_res = template_resource.TemplateResource('test_t_res',
@@ -242,7 +249,8 @@ class ProviderTemplateTest(HeatTestCase):
         env.load({'resource_registry':
                   {'DummyResource': 'test_resource.template'}})
         stack = parser.Stack(utils.dummy_context(), 'test_stack',
-                             parser.Template({}, files=files), env=env,
+                             parser.Template(empty_template, files=files),
+                             env=env,
                              stack_id=str(uuid.uuid4()))
 
         temp_res = template_resource.TemplateResource('test_t_res',
@@ -251,6 +259,7 @@ class ProviderTemplateTest(HeatTestCase):
 
     def test_properties_missing(self):
         provider = {
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Parameters': {
                 'Blarg': {'Type': 'String', 'Default': 'wibble'},
             },
@@ -272,7 +281,8 @@ class ProviderTemplateTest(HeatTestCase):
         env.load({'resource_registry':
                   {'DummyResource': 'test_resource.template'}})
         stack = parser.Stack(utils.dummy_context(), 'test_stack',
-                             parser.Template({}, files=files), env=env,
+                             parser.Template(empty_template, files=files),
+                             env=env,
                              stack_id=str(uuid.uuid4()))
 
         temp_res = template_resource.TemplateResource('test_t_res',
@@ -282,6 +292,7 @@ class ProviderTemplateTest(HeatTestCase):
 
     def test_properties_extra_required(self):
         provider = {
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Parameters': {
                 'Blarg': {'Type': 'String'},
             },
@@ -304,7 +315,8 @@ class ProviderTemplateTest(HeatTestCase):
         env.load({'resource_registry':
                   {'DummyResource': 'test_resource.template'}})
         stack = parser.Stack(utils.dummy_context(), 'test_stack',
-                             parser.Template({}, files=files), env=env,
+                             parser.Template(empty_template, files=files),
+                             env=env,
                              stack_id=str(uuid.uuid4()))
 
         temp_res = template_resource.TemplateResource('test_t_res',
@@ -337,7 +349,9 @@ class ProviderTemplateTest(HeatTestCase):
         env.load({'resource_registry':
                   {'DummyResource': 'test_resource.template'}})
         stack = parser.Stack(utils.dummy_context(), 'test_stack',
-                             parser.Template({}, files=files), env=env,
+                             parser.Template(
+                                 {'HeatTemplateFormatVersion': '2012-12-12'},
+                                 files=files), env=env,
                              stack_id=str(uuid.uuid4()))
 
         temp_res = template_resource.TemplateResource('test_t_res',
@@ -411,7 +425,8 @@ class ProviderTemplateTest(HeatTestCase):
             }
         }
         stack = parser.Stack(utils.dummy_context(), 'test_stack',
-                             parser.Template({}), stack_id=str(uuid.uuid4()))
+                             parser.Template(empty_template),
+                             stack_id=str(uuid.uuid4()))
         templ_resource = resource.Resource("test_templ_resource", json_snippet,
                                            stack)
         self.m.VerifyAll()
@@ -449,7 +464,7 @@ class ProviderTemplateTest(HeatTestCase):
         g_env.load({'resource_registry':
                    {'Test::Frodo': test_templ_name}})
         stack = parser.Stack(utils.dummy_context(), 'test_stack',
-                             parser.Template({}),
+                             parser.Template(empty_template),
                              stack_id=str(uuid.uuid4()))
 
         minimal_temp = json.dumps({'HeatTemplateFormatVersion': '2012-12-12',
@@ -475,7 +490,7 @@ class ProviderTemplateTest(HeatTestCase):
         env.load({'resource_registry':
                   {'Test::Flippy': test_templ_name}})
         stack = parser.Stack(utils.dummy_context(), 'test_stack',
-                             parser.Template({}), env=env,
+                             parser.Template(empty_template), env=env,
                              stack_id=str(uuid.uuid4()))
 
         temp_res = template_resource.TemplateResource('test_t_res',
@@ -495,7 +510,7 @@ class ProviderTemplateTest(HeatTestCase):
         g_env.load({'resource_registry':
                    {'Test::Frodo': test_templ_name}})
         stack = parser.Stack(utils.dummy_context(), 'test_stack',
-                             parser.Template({}),
+                             parser.Template(empty_template),
                              stack_id=str(uuid.uuid4()))
 
         self.m.StubOutWithMock(urlfetch, "get")
@@ -522,7 +537,7 @@ class ProviderTemplateTest(HeatTestCase):
         env.load({'resource_registry':
                   {'Test::Flippy': test_templ_name}})
         stack = parser.Stack(utils.dummy_context(), 'test_stack',
-                             parser.Template({}), env=env,
+                             parser.Template(empty_template), env=env,
                              stack_id=str(uuid.uuid4()))
 
         self.m.StubOutWithMock(urlfetch, "get")
@@ -548,7 +563,7 @@ class ProviderTemplateTest(HeatTestCase):
         env.load({'resource_registry':
                   {'Test::Flippy': test_templ_name}})
         stack = parser.Stack(utils.dummy_context(), 'test_stack',
-                             parser.Template({}), env=env,
+                             parser.Template(empty_template), env=env,
                              stack_id=str(uuid.uuid4()))
 
         self.m.ReplayAll()

heat/tests/test_resource.py

@@ -32,6 +32,9 @@ from heat.tests import generic_resource as generic_rsrc
 from heat.tests import utils
 
 
+empty_template = {"HeatTemplateFormatVersion": "2012-12-12"}
+
+
 class ResourceTest(HeatTestCase):
     def setUp(self):
         super(ResourceTest, self).setUp()
@@ -44,7 +47,7 @@ class ResourceTest(HeatTestCase):
                   {u'OS::Test::GenericResource': u'GenericResourceType'}})
 
         self.stack = parser.Stack(utils.dummy_context(), 'test_stack',
-                                  parser.Template({}), env=env,
+                                  parser.Template(empty_template), env=env,
                                   stack_id=str(uuid.uuid4()))
 
     def test_get_class_ok(self):
@@ -295,7 +298,7 @@ class ResourceTest(HeatTestCase):
         tmpl2 = {'Type': 'Foo'}
         tmpl3 = {'Type': 'Bar'}
         stack2 = parser.Stack(utils.dummy_context(), 'test_stack',
-                              parser.Template({}), stack_id=-1)
+                              parser.Template(empty_template), stack_id=-1)
         res1 = generic_rsrc.GenericResource('test_resource', tmpl1, self.stack)
         res2 = generic_rsrc.GenericResource('test_resource', tmpl2, stack2)
         res3 = generic_rsrc.GenericResource('test_resource2', tmpl3, stack2)
@@ -747,6 +750,7 @@ class ResourceAdoptTest(HeatTestCase):
     def test_adopt_resource_success(self):
         adopt_data = '{}'
         tmpl = template.Template({
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Resources': {
                 'foo': {'Type': 'GenericResourceType'},
             }
@@ -773,6 +777,7 @@ class ResourceAdoptTest(HeatTestCase):
     def test_adopt_with_resource_data_and_metadata(self):
         adopt_data = '{}'
         tmpl = template.Template({
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Resources': {
                 'foo': {'Type': 'GenericResourceType'},
             }
@@ -806,6 +811,7 @@ class ResourceAdoptTest(HeatTestCase):
                         "resources": {}
                         }'''
         tmpl = template.Template({
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Resources': {
                 'foo': {'Type': 'GenericResourceType'},
             }
@@ -834,6 +840,7 @@ class ResourceDependenciesTest(HeatTestCase):
 
     def test_no_deps(self):
         tmpl = template.Template({
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Resources': {
                 'foo': {'Type': 'GenericResourceType'},
             }
@@ -848,6 +855,7 @@ class ResourceDependenciesTest(HeatTestCase):
 
     def test_ref(self):
         tmpl = template.Template({
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Resources': {
                 'foo': {'Type': 'GenericResourceType'},
                 'bar': {
@@ -892,6 +900,7 @@ class ResourceDependenciesTest(HeatTestCase):
 
     def test_ref_nested_dict(self):
         tmpl = template.Template({
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Resources': {
                 'foo': {'Type': 'GenericResourceType'},
                 'bar': {
@@ -935,6 +944,7 @@ class ResourceDependenciesTest(HeatTestCase):
 
     def test_ref_nested_deep(self):
         tmpl = template.Template({
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Resources': {
                 'foo': {'Type': 'GenericResourceType'},
                 'bar': {
@@ -982,6 +992,7 @@ class ResourceDependenciesTest(HeatTestCase):
 
     def test_ref_fail(self):
         tmpl = template.Template({
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Resources': {
                 'foo': {'Type': 'GenericResourceType'},
                 'bar': {
@@ -1017,6 +1028,7 @@ class ResourceDependenciesTest(HeatTestCase):
 
     def test_getatt(self):
         tmpl = template.Template({
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Resources': {
                 'foo': {'Type': 'GenericResourceType'},
                 'bar': {
@@ -1060,6 +1072,7 @@ class ResourceDependenciesTest(HeatTestCase):
 
     def test_getatt_nested_dict(self):
         tmpl = template.Template({
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Resources': {
                 'foo': {'Type': 'GenericResourceType'},
                 'bar': {
@@ -1103,6 +1116,7 @@ class ResourceDependenciesTest(HeatTestCase):
 
     def test_getatt_nested_deep(self):
         tmpl = template.Template({
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Resources': {
                 'foo': {'Type': 'GenericResourceType'},
                 'bar': {
@@ -1152,6 +1166,7 @@ class ResourceDependenciesTest(HeatTestCase):
 
     def test_getatt_fail(self):
         tmpl = template.Template({
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Resources': {
                 'foo': {'Type': 'GenericResourceType'},
                 'bar': {
@@ -1187,6 +1202,7 @@ class ResourceDependenciesTest(HeatTestCase):
 
     def test_getatt_fail_nested_deep(self):
         tmpl = template.Template({
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Resources': {
                 'foo': {'Type': 'GenericResourceType'},
                 'bar': {
@@ -1232,6 +1248,7 @@ class ResourceDependenciesTest(HeatTestCase):
 
     def test_dependson(self):
         tmpl = template.Template({
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Resources': {
                 'foo': {'Type': 'GenericResourceType'},
                 'bar': {
@@ -1271,6 +1288,7 @@ class ResourceDependenciesTest(HeatTestCase):
 
     def test_dependson_fail(self):
         tmpl = template.Template({
+            'HeatTemplateFormatVersion': '2012-12-12',
             'Resources': {
                 'foo': {
                     'Type': 'GenericResourceType',
@@ -1292,7 +1310,8 @@ class MetadataTest(HeatTestCase):
             'Metadata': {'Test': 'Initial metadata'}
         }
         self.stack = parser.Stack(utils.dummy_context(),
-                                  'test_stack', parser.Template({}))
+                                  'test_stack',
+                                  parser.Template(empty_template))
         self.stack.store()
         self.res = generic_rsrc.GenericResource('metadata_resource',
                                                 tmpl, self.stack)

heat/tests/test_software_config.py

@@ -39,6 +39,7 @@ class SoftwareConfigTest(HeatTestCase):
         self.stack = parser.Stack(
             self.ctx, 'software_config_test_stack',
             template.Template({
+                'HeatTemplateFormatVersion': '2012-12-12',
                 'Resources': {
                     'config_mysql': {
                         'Type': 'OS::Heat::SoftwareConfig',

heat/tests/test_software_deployment.py

@@ -25,6 +25,7 @@ from heat.tests import utils
 class SoftwareDeploymentTest(HeatTestCase):
 
     template = {
+        'HeatTemplateFormatVersion': '2012-12-12',
         'Resources': {
             'deployment_mysql': {
                 'Type': 'OS::Heat::SoftwareDeployment',
@@ -38,6 +39,7 @@ class SoftwareDeploymentTest(HeatTestCase):
     }
 
     template_with_server = {
+        'HeatTemplateFormatVersion': '2012-12-12',
         'Resources': {
             'deployment_mysql': {
                 'Type': 'OS::Heat::SoftwareDeployment',
@@ -59,6 +61,7 @@ class SoftwareDeploymentTest(HeatTestCase):
     }
 
     template_no_signal = {
+        'HeatTemplateFormatVersion': '2012-12-12',
         'Resources': {
             'deployment_mysql': {
                 'Type': 'OS::Heat::SoftwareDeployment',
@@ -74,6 +77,7 @@ class SoftwareDeploymentTest(HeatTestCase):
     }
 
     template_delete_suspend_resume = {
+        'HeatTemplateFormatVersion': '2012-12-12',
         'Resources': {
             'deployment_mysql': {
                 'Type': 'OS::Heat::SoftwareDeployment',

heat/tests/test_stack_resource.py

@@ -28,7 +28,8 @@ from heat.tests import generic_resource as generic_rsrc
 from heat.tests import utils
 
 
-ws_res_snippet = {"Type": "some_magic_type",
+ws_res_snippet = {"HeatTemplateFormatVersion": "2012-12-12",
+                  "Type": "some_magic_type",
                   "metadata": {
                       "key": "value",
                       "some": "more stuff"}}
@@ -105,7 +106,8 @@ class StackResourceTest(HeatTestCase):
                                  MyStackResource)
         resource._register_class('GenericResource',
                                  generic_rsrc.GenericResource)
-        t = parser.Template({'Resources':
+        t = parser.Template({'HeatTemplateFormatVersion': '2012-12-12',
+                             'Resources':
                              {"provider_resource": ws_res_snippet}})
         self.parent_stack = parser.Stack(utils.dummy_context(), 'test_stack',
                                          t, stack_id=str(uuid.uuid4()))
@@ -172,7 +174,8 @@ class StackResourceTest(HeatTestCase):
         stack_resource = MyImplementedStackResource('test',
                                                     ws_res_snippet,
                                                     self.parent_stack)
-        stack_resource.child_template = mock.Mock(return_value={})
+        stack_resource.child_template = \
+            mock.Mock(return_value={'HeatTemplateFormatVersion': '2012-12-12'})
         stack_resource.child_params = mock.Mock()
         exc = exception.RequestLimitExceeded(message='Validation Failed')
         validation_mock = mock.Mock(side_effect=exc)
@@ -183,7 +186,8 @@ class StackResourceTest(HeatTestCase):
 
     def test__validate_nested_resources_checks_num_of_resources(self):
         stack_resource.cfg.CONF.set_override('max_resources_per_stack', 2)
-        tmpl = {'Resources': [1]}
+        tmpl = {'HeatTemplateFormatVersion': '2012-12-12',
+                'Resources': [1]}
         template = stack_resource.parser.Template(tmpl)
         root_resources = mock.Mock(return_value=2)
         self.parent_resource.stack.root_stack.total_resources = root_resources

heat/tests/test_structured_config.py

@@ -23,6 +23,7 @@ from heat.tests import utils
 class StructuredConfigTestJSON(HeatTestCase):
 
     template = {
+        'HeatTemplateFormatVersion': '2012-12-12',
         'Resources': {
             'config_mysql': {
                 'Type': 'OS::Heat::StructuredConfig',
@@ -70,6 +71,7 @@ class StructuredConfigTestJSON(HeatTestCase):
 class StructuredDeploymentDerivedTest(HeatTestCase):
 
     template = {
+        'HeatTemplateFormatVersion': '2012-12-12',
         'Resources': {
             'deploy_mysql': {
                 'Type': 'OS::Heat::StructuredDeployment'

heat/tests/test_template.py

@@ -78,8 +78,10 @@ class TestTemplateVersion(HeatTestCase):
             'foo': 'bar',
             'Parameters': {}
         }
-        self.assertEqual(('HeatTemplateFormatVersion', '2012-12-12'),
+        ex = self.assertRaises(exception.InvalidTemplateVersion,
-                         template.get_version(tmpl, self.versions))
+                               template.get_version, tmpl, self.versions)
+        self.assertEqual('The template version is invalid: Template version '
+                         'was not provided', str(ex))
 
     def test_ambiguous_version(self):
         tmpl = {

heat/tests/test_template_format.py

@@ -172,8 +172,8 @@ class JsonYamlResolvedCompareTest(HeatTestCase):
     def compare_stacks(self, json_file, yaml_file, parameters):
         t1 = self.load_template(json_file)
         t2 = self.load_template(yaml_file)
-        del(t2[u'HeatTemplateFormatVersion'])
         del(t1[u'AWSTemplateFormatVersion'])
+        t1[u'HeatTemplateFormatVersion'] = t2[u'HeatTemplateFormatVersion']
         stack1 = utils.parse_stack(t1, parameters)
         stack2 = utils.parse_stack(t2, parameters)
 

heat/tests/test_watch.py

@@ -46,7 +46,7 @@ class WatchRuleTest(HeatTestCase):
         # must be associated with a stack
         ctx = utils.dummy_context()
         ctx.auth_token = 'abcd1234'
-        empty_tmpl = {"template": {}}
+        empty_tmpl = {'HeatTemplateFormatVersion': '2012-12-12'}
         tmpl = parser.Template(empty_tmpl)
         stack_name = 'dummystack'
         dummy_stack = parser.Stack(ctx, stack_name, tmpl)