pkg() functions is added. The Version class is added for versions comparision and sorting. A search of the older package version is imlemented. Template engine is tested.

calculate/templates/template_engine.py

@@ -11,7 +11,7 @@ from importlib import import_module
 import re
 import os
 
-from ..utils.package import PackageAtom, PackageAtomError, MULTIPLE, NOTEXIST
+from ..utils.package import PackageAtom, PackageAtomError, NOTEXIST, Version
 from ..utils.files import join_paths
 
 
@@ -31,6 +31,42 @@ class ConditionFailed(TemplateSyntaxError):
     pass
 
 
+class Variables(MutableMapping):
+    '''Класс заглушка вместо модуля переменных для тестов.'''
+    def __init__(self, *args, **kwargs):
+        self.__attrs = dict(*args, **kwargs)
+
+    def __next__(self):
+        iterator = iter(self.__attrs)
+        return next(iterator)
+
+    def __getattribute__(self, name):
+        if name == '_Variables__attrs':
+            return super().__getattribute__(name)
+        try:
+            return self.__attrs[name]
+        except KeyError:
+            raise AttributeError(name)
+
+    def __getitem__(self, name):
+        return self.__attrs[name]
+
+    def __setitem__(self, name, value):
+        self.__attrs[name] = value
+
+    def __delitem__(self, name):
+        del self.__attrs[name]
+
+    def __iter__(self):
+        return iter(self.__attrs)
+
+    def __len__(self):
+        return len(self.__attrs)
+
+    def __repr__(self):
+        return '<Variables {}>'.format(self.__attrs)
+
+
 class ParametersProcessor:
     '''Класс для проверки и разбора параметров шаблона.'''
     available_parameters = {'name', 'path', 'append', 'chmod', 'chown',
@@ -53,13 +89,17 @@ class ParametersProcessor:
 
     package_atom_parser = PackageAtom()
 
-    def __init__(self, parameters_container=None, chroot_path='/'):
+    def __init__(self, parameters_container=None, chroot_path='/',
+                 datavars_module=Variables()):
         self.chroot_path = chroot_path
+        self.datavars_module = datavars_module
 
         self._parameters_container = parameters_container
 
         self._inspect_formats_package()
 
+        # Если добавляемый параметр нуждается в проверке -- добавляем сюда
+        # метод для проверки.
         self.checkers_list = OrderedDict({
                                  'package': self.check_package_parameter,
                                  'append': self.check_append_parameter,
@@ -74,6 +114,8 @@ class ParametersProcessor:
                                  'force': self.check_force_parameter
                                         })
 
+        # Если параметр является наследуемым только при некоторых условиях --
+        # указываем здесь эти условия.
         self.inherit_conditions = {'chmod': self.is_chmod_inheritable}
 
     def set_parameters_container(self, parameters_container):
@@ -101,7 +143,8 @@ class ParametersProcessor:
         else:
             checked_value = parameter_value
 
-        if parameter_name in self.inheritable_parameters:
+        if (parameter_name in self.inheritable_parameters and
+           self.template_type == DIR):
             if parameter_name in self.inherit_conditions:
                 if self.inherit_conditions[parameter_name](
                                                           parameter_value):
@@ -149,7 +192,7 @@ class ParametersProcessor:
         try:
             self.package_atom_parser.parse_package_parameter(parameter_value)
         except PackageAtomError as error:
-            if error.errno == NOTEXIST or error.errno == MULTIPLE:
+            if error.errno == NOTEXIST:
                 raise ConditionFailed(error.message, self.lineno)
             else:
                 raise IncorrectParameter(error.message)
@@ -248,6 +291,13 @@ class ParametersProcessor:
                                  "File from 'source' parameter does not exist")
         return os.path.normpath(real_path)
 
+    def check_env_parameter(self, parameter_value):
+        for env_value in parameter_value:
+            if env_value not in self.datavars_module:
+                raise ConditionFailed(
+                     "Modules from 'env' parameter do not exist.", self.lineno)
+        return parameter_value
+
     def check_force_parameter(self, parameter_value):
         if isinstance(parameter_value, bool):
             return parameter_value
@@ -388,42 +438,6 @@ class ParametersProcessor:
         cls.formats_inspected = True
 
 
-class Variables(MutableMapping):
-    '''Класс заглушка вместо модуля переменных для тестов.'''
-    def __init__(self, *args, **kwargs):
-        self.__attrs = dict(*args, **kwargs)
-
-    def __next__(self):
-        iterator = iter(self.__attrs)
-        return next(iterator)
-
-    def __getattribute__(self, name):
-        if name == '_Variables__attrs':
-            return super().__getattribute__(name)
-        try:
-            return self.__attrs[name]
-        except KeyError:
-            raise AttributeError(name)
-
-    def __getitem__(self, name):
-        return self.__attrs[name]
-
-    def __setitem__(self, name, value):
-        self.__attrs[name] = value
-
-    def __delitem__(self, name):
-        del self.__attrs[name]
-
-    def __iter__(self):
-        return iter(self.__attrs)
-
-    def __len__(self):
-        return len(self.__attrs)
-
-    def __repr__(self):
-        return '<Variables {}>'.format(self.__attrs)
-
-
 def resolve_or_missing(context, key, missing=missing, env={}):
     '''Переопределение функции из для поиска значений переменных из jinja2.
     Ищет переменные в datavars.'''
@@ -546,7 +560,10 @@ class CalculateExtension(Extension):
     parameters_processor = None
 
     def __init__(self, environment):
-        print('EXTENSION IS INITIALIZED')
+        super().__init__(environment)
+        self.environment = environment
+        self.environment.globals.update({'pkg': pkg})
+
         self.tags = {'calculate', 'save', 'set_var'}
         self.CONDITION_TOKENS_TYPES = {'eq', 'ne', 'lt', 'gt', 'lteq', 'gteq'}
         self.LITERAL_TOKENS_TYPES = {'string', 'integer', 'float'}
@@ -554,9 +571,7 @@ class CalculateExtension(Extension):
 
         self.parse_methods = {'calculate': self.parse_calculate,
                               'save': self.parse_save}
-
         self.parameters_processor._parameters_container = None
-        self.environment = environment
 
     def parse(self, parser):
         self.parser = parser
@@ -619,7 +634,7 @@ class CalculateExtension(Extension):
                     self.CONDITION_TOKENS_TYPES):
                 # разбираем параметр.
                 # pairs_list.append(self.get_parameter_node())
-                name_node, value_node = self.get_parameter_node()
+                name_node, value_node = self.get_parameter()
                 check_node = self.call_method('check_parameter',
                                               [name_node,
                                                value_node,
@@ -714,7 +729,7 @@ class CalculateExtension(Extension):
                            format(module_name))
         return ''
 
-    def get_parameter_node(self):
+    def get_parameter(self):
         '''Метод для разбра параметров, содержащихся в теге calculate.'''
         lineno = self.stream.current.lineno
         parameter_name = self.stream.expect('name').value
@@ -726,8 +741,10 @@ class CalculateExtension(Extension):
                 # если параметр env -- обновляем множенство значений env
                 # контекста вo время парсинга.
                 env_names = parameter_value.split(',')
+                parameter_rvalue = set()
                 for name in env_names:
                     CalculateContext._env_set.add(name.strip())
+                    parameter_rvalue.add(name.strip())
         else:
             parameter_rvalue = nodes.Const(True, lineno=lineno)
         # return nodes.Pair(parameter_name_node, parameter_rvalue)
@@ -740,12 +757,23 @@ class CalculateExtension(Extension):
 
 
 @contextfunction
-def pkg(context, * args):
+def pkg(context, *args):
+    package_atom_parser = PackageAtom()
+
     if args:
         package_atom = args[0]
+        try:
+            package_atom_parser.parse_package_parameter(package_atom)
+            atom_dictionary = package_atom_parser.atom_dictionary
+            print('atom dictionary = {}'.format(atom_dictionary['version']))
+            return atom_dictionary['version']
+        except PackageAtomError:
+            return Version()
     else:
-        package_atom = context.parent['__parameters__']['package']
-    return package_atom
+        package = context.parent['__parameters__'].package
+        if not package:
+            return Version()
+        return package['version']
 
 
 class TemplateEngine:
@@ -812,7 +840,8 @@ class TemplateEngine:
                                         __datavars__=self._datavars_module,
                                         __parameters__=self._parameters_object,
                                         __template_type__=template_type,
-                                        __DIR__=DIR, __FILE__=FILE
+                                        __DIR__=DIR, __FILE__=FILE,
+                                        Version=Version
                                              )
 
     @property

calculate/utils/package.py

@@ -7,13 +7,14 @@ from collections import OrderedDict
 from ..templates.format.contents_format import ContentsFormat
 from .files import read_file, read_link, join_paths, FilesError
 import hashlib
+import operator
 
 
 class PackageError(Exception):
     pass
 
 
-DEFAULT, NOTEXIST, NOTCORRECT, MULTIPLE = range(4)
+DEFAULT, NOTEXIST, NOTCORRECT = range(3)
 
 
 class PackageAtomError(Exception):
@@ -22,12 +23,159 @@ class PackageAtomError(Exception):
         self.errno = errno
 
 
+class VersionError(Exception):
+    pass
+
+
+class Version:
+    '''Временный класс для работы со значениями версий.'''
+    def __init__(self, version_value=None):
+        if version_value is None:
+            self._version_string = '-1'
+            self._version_value = -1
+        elif isinstance(version_value, Version):
+            self._version_string = version_value._version_string
+            self._version_value = version_value._version_value
+        else:
+            value = self._get_version_value(version_value)
+            if not value:
+                raise VersionError(
+                            "Can't initialize Version object using '{0}'"
+                            " value with type {1}".format(version_value,
+                                                          type(version_value)))
+            self._version_string = str(version_value)
+            self._version_value = value
+
+    def _get_version_value(self, version):
+        if isinstance(version, Version):
+            return version._version_value
+
+        elif isinstance(version, int):
+            version_value = [str(version)]
+
+        elif isinstance(version, float):
+            version_value = []
+            version = str(version).split('.')
+            for version_part in version:
+                version_value.append(int(version_part.strip()))
+
+        elif isinstance(version, str):
+            version_value = []
+
+            if '-' in version:
+                version = version.split('-')[0]
+            if '_' in version:
+                version = version.split('_')[0]
+
+            for version_part in version.split('.'):
+                if version_part.isdigit():
+                    version_part = int(version_part)
+                    version_value.append(version_part)
+                else:
+                    return False
+        else:
+            return False
+
+        return version_value
+
+    def _use_compare_operation(self, compare_operator, other_value):
+        '''Перегрузка x < y.'''
+        version_value = self._version_value[:]
+
+        other_value_length = len(other_value)
+        version_value_length = len(version_value)
+
+        if other_value_length < version_value_length:
+            for counter in range(version_value_length - other_value_length):
+                other_value.append(0)
+        elif version_value_length < other_value_length:
+            for counter in range(other_value_length - version_value_length):
+                version_value.append(0)
+
+        for lvalue, rvalue in zip(version_value, other_value):
+            if compare_operator(lvalue, rvalue):
+                return True
+
+    def __lt__(self, other):
+        '''Перегрузка x < y.'''
+        other_value = self._get_version_value(other)
+        if not other_value:
+            raise VersionError(
+                            "Unable to compare Version object with the '{0}'"
+                            " value of '{1}' type".format(other, type(other)))
+
+        return self._use_compare_operation(operator.lt, other_value)
+
+    def __le__(self, other):
+        '''Перегрузка x <= y.'''
+        other_value = self._get_version_value(other)
+        if not other_value:
+            raise VersionError(
+                            "Unable to compare Version object with the '{0}'"
+                            " value of '{1}' type".format(other, type(other)))
+
+        return self._use_compare_operation(operator.le, other_value)
+
+    def __eq__(self, other):
+        '''Перегрузка x == y.'''
+        other_value = self._get_version_value(other)
+        if not other_value:
+            raise VersionError(
+                            "Unable to compare Version object with the '{0}'"
+                            " value of '{1}' type".format(other, type(other)))
+
+        return self._use_compare_operation(operator.eq, other_value)
+
+    def __ne__(self, other):
+        '''Перегрузка x != y.'''
+        other_value = self._get_version_value(other)
+        if not other_value:
+            raise VersionError(
+                            "Unable to compare Version object with the '{0}'"
+                            " value of '{1}' type".format(other, type(other)))
+
+        return self._use_compare_operation(operator.ne, other_value)
+
+    def __gt__(self, other):
+        '''Перегрузка x > y.'''
+        other_value = self._get_version_value(other)
+        if not other_value:
+            raise VersionError(
+                            "Unable to compare Version object with the '{0}'"
+                            " value of '{1}' type".format(other, type(other)))
+
+        return self._use_compare_operation(operator.gt, other_value)
+
+    def __ge__(self, other):
+        '''Перегрузка x >= y.'''
+        other_value = self._get_version_value(other)
+        if not other_value:
+            raise VersionError(
+                            "Unable to compare Version object with the '{0}'"
+                            " value of '{1}' type".format(other, type(other)))
+
+        return self._use_compare_operation(operator.ge, other_value)
+
+    def __hash__(self):
+        return hash(self._version_string)
+
+    def __repr__(self):
+        return '<Version: {}>'.format(self._version_string)
+
+    def __bool__(self):
+        if self._version_value == [-1]:
+            return False
+        else:
+            return True
+
+
 class PackageAtom:
     atom_regex = re.compile(r'''(?P<category>[^\s/]*)/
-                                (?P<name>[^\s:]*)
-                                (?P<slot>:\S*)?
-                                (?P<uses>(?:\s+\S*)*)
-                                ''', re.VERBOSE)
+                                (?P<name>[^\s\-:]*)
+                                (?P<version>-\d[^\s:]*)?
+                                (?P<slot>:[^\s\[]*)?\s*
+                                (?P<uses>\[\S*(?:\s+\S*)*\])?''',
+                            re.VERBOSE)
 
     def __init__(self, pkg_path='/var/db/pkg',
                  chroot_path='/'):
@@ -41,72 +189,132 @@ class PackageAtom:
         self.package_atom = ''
         self._atom_dictionary = {}
 
-    def parse_package_parameter(self, package_atom,
-                                add_slot=False, add_uses=False):
+    def parse_package_parameter(self, package_atom):
         self.package_atom = package_atom
         self._atom_dictionary = {}
 
         parsing_result = self.atom_regex.search(package_atom)
 
-        if not parsing_result or parsing_result.string != package_atom:
+        if (not parsing_result or parsing_result.string != package_atom or
+           not parsing_result.groupdict()['category'] or
+           not parsing_result.groupdict()['name']):
             raise PackageAtomError("'package' parameter value '{}' is not"
                                    " correct".format(package_atom),
                                    errno=NOTCORRECT)
 
-        if 'category' in parsing_result.groupdict():
-            self._atom_dictionary['category'] = parsing_result.groupdict(
+        self._atom_dictionary['category'] = parsing_result.groupdict(
                                                                   )['category']
 
-        if 'name' in parsing_result.groupdict():
-            self._atom_dictionary['name'] = parsing_result.groupdict()['name']
+        self._atom_dictionary['name'] = parsing_result.groupdict()['name']
 
-        self._check_package_existance()
+        if parsing_result.groupdict()['version']:
+            version_value = parsing_result.groupdict()['version'].strip('-')
 
-        if ('slot' in parsing_result.groupdict() and
-           parsing_result.groupdict()['slot'] and
+            self._atom_dictionary['version'] = Version(version_value)
+
+        if (parsing_result.groupdict()['slot'] and
            parsing_result.groupdict()['slot'] != ':'):
             self._atom_dictionary['slot'] = parsing_result.groupdict(
                                                                   )['slot'][1:]
-        elif add_slot:
-            self._atom_dictionary['slot'] = self._get_slot_value()
 
-        if ('uses' in parsing_result.groupdict() and
-           parsing_result.groupdict()['uses']):
+        if parsing_result.groupdict()['uses']:
             self._atom_dictionary['uses'] = []
-            uses = parsing_result.groupdict()['uses'].strip().split(' ')
-            for use_flag in uses:
+            uses = parsing_result.groupdict()['uses'].strip().rstrip(']').\
+                lstrip('[')
+
+            for use_flag in uses.split():
                 self._atom_dictionary['uses'].append(use_flag.strip())
 
-        elif add_uses:
-            self._atom_dictionary['uses'] = self._get_use_flags_value()
+        self._check_package_existance()
 
     def _check_package_existance(self, package_atom=''):
         if package_atom:
             self.parse_package_parameter(package_atom)
             return True
-        elif (self._atom_dictionary['category'] and
-              self._atom_dictionary['name']):
-            glob_result = glob.glob(
-              '{0}/{1}/{2}*/CONTENTS'.format(self.pkg_path,
+        else:
+            if 'version' in self._atom_dictionary:
+                full_name = self._atom_dictionary['name'] + '-' +\
+                    self._atom_dictionary['version']._version_string
+            else:
+                full_name = self._atom_dictionary['name']
+
+            if 'version' not in self._atom_dictionary:
+                glob_result = glob.glob(
+                 r'{0}/{1}/{2}-[0-9]*/CONTENTS'.format(
+                                             self.pkg_path,
                                              self._atom_dictionary['category'],
-                                             self._atom_dictionary['name']))
+                                             full_name))
+            else:
+                glob_result = glob.glob(
+                 r'{0}/{1}/{2}*/CONTENTS'.format(
+                                             self.pkg_path,
+                                             self._atom_dictionary['category'],
+                                             full_name))
+
             if not glob_result:
                 raise PackageAtomError("Package from 'package' parameter value"
                                        " '{}' does not exist".format(
                                                             self.package_atom),
                                        errno=NOTEXIST)
-            elif len(glob_result) == 1:
+
+            if len(glob_result) == 1:
                 contents_path = next(iter(glob_result))
+                self._check_slot_value(contents_path)
+                self._check_use_flags_value(contents_path)
+
                 self._atom_dictionary['name'] = contents_path.split('/')[-2]
                 self._atom_dictionary['contents'] = contents_path
             else:
-                raise PackageAtomError("'package' parameter value '{}' matches"
-                                       " multiple installed packages".format(
+                packages = dict()
+                for contents_path in glob_result:
+                    package_info = dict()
+                    try:
+                        self._check_slot_value(contents_path)
+                        self._check_use_flags_value(contents_path)
+                        package_info['name'] = contents_path.split('/')[-2]
+                        package_info['version'] = Version(
+                                         package_info['name'].split('-', 1)[1])
+                    except PackageAtomError:
+                        continue
+                    packages[contents_path] = package_info
+
+                if not packages:
+                    raise PackageAtomError(
+                                       "Package from 'package' parameter value"
+                                       " '{}' does not exist".format(
                                                             self.package_atom),
-                                       errno=MULTIPLE)
+                                       errno=NOTEXIST)
+
+                if len(packages) == 1:
+                    contents_path = next(iter(packages.keys()))
+                    self._atom_dictionary['contents'] = contents_path
+                    self._atom_dictionary.update(packages[contents_path])
+                else:
+                    contents_path = sorted(
+                                packages.keys(),
+                                key=lambda path: packages[path]['version'])[-1]
+                    self._atom_dictionary['contents'] = contents_path
+                    self._atom_dictionary.update(packages[contents_path])
+
+    def _check_slot_value(self, contents_path):
+        slot = self._get_slot_value(contents_path)
+        if 'slot' in self._atom_dictionary:
+            if slot != self._atom_dictionary['slot']:
+                raise PackageAtomError("Package from 'package' parameter value"
+                                       " '{}' does not exist".format(
+                                                            self.package_atom),
+                                       errno=NOTEXIST)
+
+    def _check_use_flags_value(self, contents_path):
+        use_flags = self._get_use_flags_value(contents_path)
+        if 'uses' in self._atom_dictionary:
+            if self._atom_dictionary['uses'] not in use_flags:
+                raise PackageAtomError("Package from 'package' parameter value"
+                                       " '{}' does not exist".format(
+                                                            self.package_atom),
+                                       errno=NOTEXIST)
 
-    def _get_slot_value(self):
-        contents_path = self._atom_dictionary['contents']
+    def _get_slot_value(self, contents_path):
         slot_path = os.path.join(os.path.dirname(contents_path), 'SLOT')
         try:
             return read_file(slot_path).strip('\n')
@@ -114,8 +322,7 @@ class PackageAtom:
             raise PackageAtomError("could not read slot value for"
                                    " 'package': {}".format(self.package_atom))
 
-    def _get_use_flags_value(self):
-        contents_path = self._atom_dictionary['contents']
+    def _get_use_flags_value(self, contents_path):
         use_path = os.path.join(os.path.dirname(contents_path), 'USE')
         try:
             return read_file(use_path).strip('\n').split(' ')

run.py

@@ -1,6 +1,9 @@
 from calculate.templates.template_engine import TemplateEngine, DIR, Variables
+
 from calculate.templates.template_processor import TemplateAction
 
+from calculate.utils.package import Version
+
 
 main = Variables({'cl_template_path':
                   ('tests/templates/testfiles/template_dir_1,'
@@ -11,22 +14,29 @@ main = Variables({'cl_template_path':
 datavars = Variables({'main': main})
 
 
-try:
-    template_engine = TemplateEngine(
-                                datavars_module=datavars,
-                                appends_set=TemplateAction().available_appends)
-
-    template_engine.process_template_from_string(
-           ("{% calculate package = 'dev-lang/python-3.6', action = 'install',"
-            "chmod = 'rwxr-xr-x', append = 'join', force %}"),
-           DIR)
-
-    template_engine.parameters.print_parameters_for_debug()
-
-    template_engine.process_template_from_string(
-          "{% calculate package = 'dev-lang/python-2.7', action = 'update' %}",
-          DIR)
-
-    template_engine.parameters.print_parameters_for_debug()
-except Exception as error:
-    print(str(error))
+template_engine = TemplateEngine(
+                            datavars_module=datavars,
+                            appends_set=TemplateAction().available_appends)
+
+template_engine.process_template_from_string(
+       ("{% calculate package = 'dev-lang/python', action = 'install',"
+        "chmod = 'rwxr-xr-x', append = 'join', force %}"),
+       DIR)
+
+template_engine.parameters.print_parameters_for_debug()
+
+print('\nSECOND TEMPLATE\n')
+template_engine.process_template_from_string(
+        '''{% calculate package = 'dev-lang/python-2.7', action = 'update' -%}
+{% if pkg() < '3.6.9' -%}
+The package exists.
+{% else -%}
+The package does not exist.
+{% endif -%}
+{% if Version('12.3.4-r1') < '12.2.5' %}
+Version is correct.
+{% endif -%}''',
+        DIR)
+
+template_engine.parameters.print_parameters_for_debug()
+print('\nTEMPLATE TEXT:\n{0}'.format(template_engine.template_text))

tests/templates/test_template_engine.py

@@ -1,6 +1,7 @@
 import pytest
 from calculate.templates.template_engine import TemplateEngine, Variables,\
-                                                ConditionFailed
+                                                ConditionFailed, DIR, FILE
+from calculate.templates.template_processor import TemplateAction
 
 
 PARAMETERS_SET = {'name', 'path', 'append', 'chmod', 'chown',
@@ -11,43 +12,50 @@ PARAMETERS_SET = {'name', 'path', 'append', 'chmod', 'chown',
                   'postmerge', 'action'}
 
 
+APPENDS_SET = TemplateAction().available_appends
+
+
 @pytest.mark.template_engine
 class TestTemplateEngine():
     def test_if_an_input_template_contains_calculate_tag_with_some_parameters__the_template_engine_object_will_collect_its_parameters(self):
         input_template = '''{% calculate name = 'filename', path = '/etc/path', force %}'''
-        parameters = {'name': 'filename', 'path': '/etc/path', 'force': True}
-        template_engine = TemplateEngine(parameters_set=PARAMETERS_SET)
-        template_engine.process_template_from_string(input_template)
+        template_engine = TemplateEngine(appends_set=APPENDS_SET)
+        template_engine.process_template_from_string(input_template, DIR)
+
         output_parameters = template_engine.parameters
-        assert output_parameters == parameters
+        assert (output_parameters.name == 'filename' and
+                output_parameters.path == '/etc/path' and
+                output_parameters.force)
 
     def test_if_an_input_template_binded_with_datavars_module__variables_available_in_a_template(self):
         input_template = '''{% calculate name = vars.var_1, path = vars.var_2, autoupdate %}'''
-        parameters = {'name': 'filename', 'path': '/etc/path',
-                      'autoupdate': True}
         datavars_module = Variables({'vars':
                                      Variables({'var_1': 'filename',
                                                 'var_2': '/etc/path'})})
-        template_engine = TemplateEngine(parameters_set=PARAMETERS_SET,
+        template_engine = TemplateEngine(appends_set=APPENDS_SET,
                                          datavars_module=datavars_module)
-        template_engine.process_template_from_string(input_template)
+        template_engine.process_template_from_string(input_template, FILE)
+
         output_parameters = template_engine.parameters
-        assert output_parameters == parameters
+        assert (output_parameters.name == 'filename' and
+                output_parameters.path == '/etc/path' and
+                output_parameters.autoupdate)
 
     def test_if_an_input_template_contains_env_parameter_in_which_module_name_is_assigned__the_variables_from_this_module_can_be_used_in_template_without_determining_of_their_module(self):
         input_template = '''{% calculate name = vars.var_1, path = var_3, env = 'other_vars' %}'''
-        parameters = {'name': 'filename', 'path': '/etc/other_path',
-                      'env': 'other_vars'}
         datavars_module = Variables({'vars':
                                      Variables({'var_1': 'filename',
                                                 'var_2': '/etc/path'}),
                                      'other_vars':
                                      Variables({'var_3': '/etc/other_path'})})
-        template_engine = TemplateEngine(parameters_set=PARAMETERS_SET,
+        template_engine = TemplateEngine(appends_set=APPENDS_SET,
                                          datavars_module=datavars_module)
-        template_engine.process_template_from_string(input_template)
+        template_engine.process_template_from_string(input_template, DIR)
+
         output_parameters = template_engine.parameters
-        assert output_parameters == parameters
+        assert (output_parameters.name == 'filename' and
+                output_parameters.path == '/etc/other_path' and
+                output_parameters.env == 'other_vars')
 
     def test_if_an_input_template_contains_condition_and_it_is_True__the_template_engine_object_will_be_initialized_without_any_exceptions(self):
         input_template = '''{% calculate vars.var_1 < vars.var_2 or (not (var_3 == 'required status') and vars.var_4), env = 'vars' %}'''
@@ -56,10 +64,11 @@ class TestTemplateEngine():
                                                 'var_2': 1.2,
                                                 'var_3': 'unrequired status',
                                                 'var_4': True})})
-        template_engine = TemplateEngine(parameters_set=PARAMETERS_SET,
+        template_engine = TemplateEngine(appends_set=APPENDS_SET,
                                          datavars_module=datavars_module)
+
         try:
-            template_engine.process_template_from_string(input_template)
+            template_engine.process_template_from_string(input_template, FILE)
         except ConditionFailed:
             pytest.fail('Unexpected ConditionFailed exception.')
 
@@ -74,17 +83,16 @@ class TestTemplateEngine():
                                      Variables({'var_3': '/etc/other_path',
                                                 'var_4': 12, 'var_5': 1.2,
                                                 'var_6': 'value'})})
-        template_engine = TemplateEngine(parameters_set=PARAMETERS_SET,
+        template_engine = TemplateEngine(appends_set=APPENDS_SET,
                                          datavars_module=datavars_module)
+
         with pytest.raises(ConditionFailed):
-            template_engine.process_template_from_string(input_template)
+            template_engine.process_template_from_string(input_template, DIR)
 
     def test_if_an_input_template_contains_several_calculate_tags__the_template_engine_will_parse_them_all_and_will_contain_all_parameters_and_result_of_all_conditions(self):
         input_template = '''{% calculate name = vars.var_1, var_4 > var_5 %}
                             {% calculate path = var_3, var_6 == 'value' %}
                             {% calculate env = 'other_vars'%}'''
-        parameters = {'name': 'filename', 'path': '/etc/other_path',
-                      'env': 'other_vars'}
         datavars_module = Variables({'vars':
                                      Variables({'var_1': 'filename',
                                                 'var_2': '/etc/path'}),
@@ -92,10 +100,14 @@ class TestTemplateEngine():
                                      Variables({'var_3': '/etc/other_path',
                                                 'var_4': 12, 'var_5': 1.2,
                                                 'var_6': 'value'})})
-        template_engine = TemplateEngine(parameters_set=PARAMETERS_SET,
+        template_engine = TemplateEngine(appends_set=APPENDS_SET,
                                          datavars_module=datavars_module)
-        template_engine.process_template_from_string(input_template)
-        assert template_engine.parameters == parameters
+        template_engine.process_template_from_string(input_template, FILE)
+
+        output_parameters = template_engine.parameters
+        assert (output_parameters.name == 'filename' and
+                output_parameters.path == '/etc/other_path' and
+                output_parameters.env == 'other_vars')
 
     def test_if_an_input_template_contains_variables_in_its_text__the_rendered_text_will_contain_values_of_this_variables(self):
         input_template = '''{% calculate name = 'filename', force -%}
@@ -112,9 +124,10 @@ class TestTemplateEngine():
                                      'vars_2':
                                      Variables({'var_3': 'value_1',
                                                 'var_4': 'value_2'})})
-        template_engine = TemplateEngine(parameters_set=PARAMETERS_SET,
+        template_engine = TemplateEngine(appends_set=APPENDS_SET,
                                          datavars_module=datavars_module)
-        template_engine.process_template_from_string(input_template)
+        template_engine.process_template_from_string(input_template, DIR)
+
         text = template_engine.template_text
         assert text == output_text
 
@@ -129,8 +142,9 @@ class TestTemplateEngine():
         datavars_module = Variables({'vars_1':
                                      Variables({'var_1': 12,
                                                 'var_2': 1.2})})
-        template_engine = TemplateEngine(parameters_set=PARAMETERS_SET,
+        template_engine = TemplateEngine(appends_set=APPENDS_SET,
                                          datavars_module=datavars_module)
-        template_engine.process_template_from_string(input_template)
+        template_engine.process_template_from_string(input_template, FILE)
+
         text = template_engine.template_text
         assert text == output_text