Update Heat template fixture

Change-Id: I91f48bd2f41e25b0b208ceff048cd61a3b90ff3c

tobiko/openstack/heat/_template.py

@@ -16,7 +16,7 @@ from __future__ import absolute_import
 import collections
 import os
 import sys
-import typing  # noqa
+import typing
 
 from heatclient.common import template_utils
 import yaml
@@ -31,54 +31,56 @@ TEMPLATE_DIRS = list(sys.path)
 
 class HeatTemplateFixture(tobiko.SharedFixture):
 
-    template = None  # type: typing.Dict[str, typing.Any]
-    template_files = None
-    template_yaml = None
+    template_yaml: str
 
-    def __init__(self, template=None, template_files=None):
+    def __init__(self,
+                 template: typing.Mapping[str, typing.Any] = None,
+                 template_files: typing.Mapping = None):
         super(HeatTemplateFixture, self).__init__()
-        if template:
-            self.template = template
-        if template_files:
-            self.template_files = template_files
+        self.template: typing.Dict[str, typing.Any] = {}
+        if template is not None:
+            self.template.update(template)
+        self.template_files: typing.Dict[str, typing.Any] = {}
+        if template_files is not None:
+            self.template_files.update(template_files)
 
     def setup_fixture(self):
         self.setup_template()
 
     def setup_template(self):
+        # Ensure main sections are dictionaries
+        tobiko.check_valid_type(self.outputs, collections.Mapping)
+        tobiko.check_valid_type(self.parameters, collections.Mapping)
+        tobiko.check_valid_type(self.resources, collections.Mapping)
         self.template_yaml = yaml.safe_dump(self.template)
 
     @property
-    def outputs(self):
-        template = self.template
-        return template and template.get('outputs') or None
+    def outputs(self) -> typing.Dict[str, typing.Any]:
+        return dict(self.template.get('outputs', {}))
 
     @property
-    def parameters(self):
-        template = self.template
-        return template and template.get('parameters') or None
+    def parameters(self) -> typing.Dict[str, typing.Any]:
+        return dict(self.template.get('parameters', {}))
 
     @property
-    def resources(self):
-        template = self.template
-        return template and template.get('resources') or None
+    def resources(self) -> typing.Dict[str, typing.Any]:
+        return dict(self.template.get('resources', {}))
 
 
 class HeatTemplateFileFixture(HeatTemplateFixture):
 
-    template_file = None
-    template_dirs = None
-    template_files = None
-
-    def __init__(self, template_file=None, template_dirs=None):
+    def __init__(self,
+                 template_file: str,
+                 template_dirs: typing.Iterable[str] = None):
         super(HeatTemplateFileFixture, self).__init__()
-        if template_file:
-            self.template_file = template_file
-        if template_dirs:
-            self.template_dirs = template_dirs
+        self.template_file = template_file
+        if template_dirs is None:
+            template_dirs = TEMPLATE_DIRS
+        self.template_dirs: typing.List[str] = list(template_dirs)
 
     def setup_template(self):
-        if self.template_dirs or not os.path.isfile(self.template_file):
+        template_file = self.template_file
+        if self.template_dirs or not os.path.isfile(template_file):
             template_dirs = self.template_dirs or TEMPLATE_DIRS
             template_file = find_heat_template_file(
                 template_file=self.template_file,
@@ -90,25 +92,31 @@ class HeatTemplateFileFixture(HeatTemplateFixture):
         super(HeatTemplateFileFixture, self).setup_template()
 
 
-def heat_template(obj, template_files=None):
+HeatTemplateType = typing.Union[typing.Mapping[str, typing.Any],
+                                HeatTemplateFixture]
+
+
+def heat_template(obj: HeatTemplateType,
+                  template_files: typing.Mapping = None) \
+        -> HeatTemplateFixture:
     if isinstance(obj, collections.Mapping):
         template = HeatTemplateFixture(template=obj,
                                        template_files=template_files)
     else:
         template = tobiko.get_fixture(obj)
 
-    if not isinstance(template, HeatTemplateFixture):
-        msg = "Object {!r} is not an HeatTemplateFixture".format(template)
-        raise TypeError(msg)
+    tobiko.check_valid_type(template, HeatTemplateFixture)
     return template
 
 
-def heat_template_file(template_file, template_dirs=None):
+def heat_template_file(template_file: str,
+                       template_dirs: typing.Iterable[str] = None):
     return HeatTemplateFileFixture(template_file=template_file,
                                    template_dirs=template_dirs)
 
 
-def find_heat_template_file(template_file, template_dirs):
+def find_heat_template_file(template_file: str,
+                            template_dirs: typing.Iterable[str]):
     for template_dir in template_dirs:
         template_path = os.path.join(template_dir, template_file)
         if os.path.exists(template_path):

tobiko/tests/unit/openstack/heat/test_template.py

@@ -35,9 +35,8 @@ class HeatTemplateFileTest(openstack.OpenstackTest):
                                            template_dirs=template_dirs)
         self.assertIsInstance(template, heat.HeatTemplateFileFixture)
         self.assertEqual(template_file, template.template_file)
-        self.assertIsNone(template.template)
-        self.assertIsNone(template.template_files)
-        self.assertIsNone(template.template_yaml)
+        self.assertEqual({}, template.template)
+        self.assertEqual({}, template.template_files)
 
         tobiko.setup_fixture(template)
         template_files, template_dict = template_utils.get_template_contents(