Removing default version for templates

There are a lot of places in unittests where defined template
does not contain template version. This section should be added
everywhere. At this moment if template has not version field,
exception should be raised.

Closes-Bug: #1289487
Change-Id: I422b1468bfd57880fda0dac15ad53932fce7a447

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()
+    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.',
                'Resources': {
                    '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)