The merging of the template engine and the parameter's processor is finished. Some tests fail now.

calculate/templates/template_engine.py

@@ -11,7 +11,7 @@ from importlib import import_module
 import re
 import os
 
-from ..utils.package import PackageAtom, PackageAtomError
+from ..utils.package import PackageAtom, PackageAtomError, MULTIPLE, NOTEXIST
 from ..utils.files import join_paths
 
 
@@ -31,27 +31,21 @@ class ConditionFailed(TemplateSyntaxError):
     pass
 
 
-class TemplateParametersChecker:
-    '''Класс для хранения, проверки и разбора параметров шаблона.'''
+class ParametersProcessor:
+    '''Класс для проверки и разбора параметров шаблона.'''
     available_parameters = {'name', 'path', 'append', 'chmod', 'chown',
                             'autoupdate', 'env', 'force', 'source', 'format',
                             'protected', 'mirror', 'run', 'exec', 'env',
                             'package', 'merge', 'postmerge', 'action',
                             'rebuild', 'restart', 'stop', 'start'}
 
-    inheritable_parameters = {'chmod': (None, None), 'chown': (None, None),
-                              'autoupdate': (None, None), 'env': (None, None),
-                              'package': (None, None), 'action': (None, None)}
+    inheritable_parameters = {'chmod', 'chown', 'autoupdate', 'env',
+                              'package', 'action'}
 
     available_appends = set()
 
-    directory_default_values = {'chown': 'root:root',
-                                'chmod': '755'}
-
-    file_default_values = {'chown': 'root:root',
-                           'chmod': '644'}
-
     available_formats = set()
+
     format_is_inspected = False
 
     chmod_value_regular = re.compile(
@@ -59,12 +53,11 @@ class TemplateParametersChecker:
 
     package_atom_parser = PackageAtom()
 
-    def __init__(self, parameters_container, template_type, parameters=dict(),
-                 chroot_path='/'):
-        self.template_type = template_type
+    def __init__(self, parameters_container=None, chroot_path='/'):
         self.chroot_path = chroot_path
 
         self._parameters_container = parameters_container
+
         self._inspect_formats_package()
 
         self.checkers_list = OrderedDict({
@@ -81,17 +74,10 @@ class TemplateParametersChecker:
                                  'force': self.check_force_parameter
                                         })
 
-        try:
-            if template_type == DIR:
-                self.check_template_parameters(self.directory_default_values)
-            elif template_type == FILE:
-                self.check_template_parameters(self.file_default_values)
-        except IncorrectParameter as error:
-            raise DefaultParameterError('Default parameter value error: {}'.
-                                        format(str(error)))
+        self.inherit_conditions = {'chmod': self.is_chmod_inheritable}
 
-        if parameters:
-            self.check_template_parameters(parameters)
+    def set_parameters_container(self, parameters_container):
+        self._parameters_container = parameters_container
 
     def __getattr__(self, parameter_name):
         if parameter_name not in self.available_parameters:
@@ -102,50 +88,72 @@ class TemplateParametersChecker:
         else:
             return self._parameters_container[parameter_name]
 
-    def check_template_parameter(self, parameter_name, parameter_value):
-        # Если параметр наследуем и уже встречался до этого с тем же
-        # значением -- второй раз не проверяем его.
-        if (parameter_name in self.inheritable_parameters and
-           parameter_value == self.inheritable_parameters[parameter_name][0]):
-            return self.inheritable_parameters[parameter_name][1]
+    def check_template_parameter(self, parameter_name, parameter_value,
+                                 template_type, lineno):
+        self.lineno = lineno
+        self.template_type = template_type
 
         if parameter_name not in self.available_parameters:
             raise IncorrectParameter("Unknown parameter '{0}'".
                                      format(parameter_name))
         elif parameter_name in self.checkers_list:
-            checked_value = self.checkers_list[parameter_name](
-                                                               parameter_value)
-            if parameter_name in self.inheritable_parameters:
-                self.inheritable_parameters[parameter_name] =\
-                        (parameter_value, checked_value)
-            return checked_value
+            checked_value = self.checkers_list[parameter_name](parameter_value)
+        else:
+            checked_value = parameter_value
+
+        if parameter_name in self.inheritable_parameters:
+            if parameter_name in self.inherit_conditions:
+                if self.inherit_conditions[parameter_name](
+                                                          parameter_value):
+                    self._parameters_container.set_inheritable(
+                                           {parameter_name: checked_value})
+                    return
+            else:
+                self._parameters_container.set_inheritable(
+                                           {parameter_name: checked_value})
+                return
 
-    def check_template_parameters(self, parameters):
-        for parameter_name in parameters:
-            if (parameter_name in self.inheritable_parameters and
-               parameters[parameter_name] ==
-               self.inheritable_parameters[parameter_name][0]):
-                self._parameters_container[parameter_name] =\
-                    self.inheritable_parameters[parameter_name][1]
-                continue
+        self._parameters_container.set_parameter(
+                                           {parameter_name: checked_value})
 
+    def check_template_parameters(self, parameters, template_type, lineno):
+        self.template_type = template_type
+
+        for parameter_name in parameters:
             if parameter_name not in self.available_parameters:
                 raise IncorrectParameter("Unknown parameter '{0}'".
                                          format(parameter_name))
             elif parameter_name in self.checkers_list:
-                parameter_value = self.checkers_list[parameter_name](
-                                                 parameters[parameter_name]
-                                                                    )
-                self._parameters_container[parameter_name] = parameter_value
-                if parameter_name in self.inheritable_parameters:
-                    self.inheritable_parameters[parameter_name] =\
-                            (parameter_value, parameters[parameter_name])
+                checked_value = self.checkers_list[parameter_name](
+                                                     parameters[parameter_name]
+                                                                  )
+            else:
+                checked_value = parameters[parameter_name]
+
+            if parameter_name in self.inheritable_parameters:
+                if parameter_name in self.inherit_conditions:
+                    if self.inherit_conditions[parameter_name](
+                                               parameters[parameter_name]):
+                        self._parameters_container.set_inheritable(
+                                              parameter_name=checked_value)
+                        continue
+                else:
+                    self._parameters_container.set_inheritable(
+                                              parameter_name=checked_value)
+                    continue
+
+            self._parameters_container.set_parameter(
+                                              parameter_name=checked_value)
 
     def check_package_parameter(self, parameter_value):
         try:
             self.package_atom_parser.parse_package_parameter(parameter_value)
         except PackageAtomError as error:
-            raise IncorrectParameter(str(error))
+            if error.errno == NOTEXIST or error.errno == MULTIPLE:
+                raise ConditionFailed(error.message, self.lineno)
+            else:
+                raise IncorrectParameter(error.message)
+
         parameter_value = self.package_atom_parser.atom_dictionary
         return parameter_value
 
@@ -254,6 +262,12 @@ class TemplateParametersChecker:
             raise IncorrectParameter(
                                     "'autoupdate' parameter value is not bool")
 
+    def is_chmod_inheritable(self, parameter_value):
+        chmod_regex = re.compile(r'\d+')
+        if chmod_regex.search(parameter_value):
+            return False
+        return True
+
     def get_chown_values(self, chown: str):
         """Получить значения uid и gid из параметра chown."""
         if chown and ':' in chown:
@@ -454,37 +468,66 @@ class ParametersContainer(MutableMapping):
     '''Класс для хранения параметров, взятых из шаблона, и передачи
     их шаблонизатору.'''
     def __init__(self, parameters_dictionary={}):
-        self.__parameters = parameters_dictionary
+        self.__parameters = {}
+        self.__inheritable = parameters_dictionary
+
         self._new_template = True
 
-    def set_parameters(self, *args, **kwargs):
-        parameters = dict(*args, **kwargs)
-        self.__parameters.update(parameters)
+    def set_parameter(self, item_to_add: dict):
+        self.__parameters.update(item_to_add)
+
+    def set_inheritable(self, item_to_add: dict):
+        self.__inheritable.update(item_to_add)
+
+    def get_inheritables(self):
+        return ParametersContainer(self.__inheritable.copy())
+
+    def print_parameters_for_debug(self):
+        print('Parameters:')
+        for parameter_name in self.__parameters:
+            print('{0}: {1}'.format(parameter_name,
+                                    self.__parameters[parameter_name]))
+        print('Inherited:')
+        for parameter_name in self.__inheritable:
+            print('{0}: {1}'.format(parameter_name,
+                                    self.__inheritable[parameter_name]))
 
     def __getattr__(self, parameter_name):
         if (parameter_name not in
-           TemplateParametersChecker.available_parameters):
+           ParametersProcessor.available_parameters):
             raise IncorrectParameter("Unknown parameter: '{}'".
                                      format(parameter_name))
-        elif parameter_name not in self.__parameters:
-            return False
-        else:
+
+        if parameter_name in self.__parameters:
             return self.__parameters[parameter_name]
+        elif parameter_name in self.__inheritable:
+            return self.__inheritable[parameter_name]
+        else:
+            return False
 
     def __getitem__(self, name):
-        return self.__parameters[name]
+        if name in self.__parameters:
+            return self.__parameters[name]
+        elif name in self.__inheritable:
+            return self.__inheritable[name]
+        else:
+            raise KeyError()
 
     def __setitem__(self, name, value):
         self.__parameters[name] = value
 
     def __delitem__(self, name):
-        del self.__parameters[name]
+        if name in self.__parameters:
+            del self.__parameters[name]
+
+        if name in self.__inheritable:
+            del self.__inheritable[name]
 
     def __iter__(self):
-        return iter(self.__parameters)
+        return iter(set(self.__parameters).union(self.__inheritable))
 
     def __len__(self):
-        return len(self.__parameters)
+        return len(set(self.__parameters).union(self.__inheritable))
 
     def __repr__(self):
         return '<ParametersContainer: {0}>'.format(self.__parameters)
@@ -497,8 +540,11 @@ class ParametersContainer(MutableMapping):
 class CalculateExtension(Extension):
     '''Класс расширения для jinja2, поддерживающий теги calculate-шаблонов.'''
     _parameters_set = set()
+
     _datavars = Variables()
 
+    parameters_processor = None
+
     def __init__(self, environment):
         print('EXTENSION IS INITIALIZED')
         self.tags = {'calculate', 'save', 'set_var'}
@@ -509,12 +555,10 @@ class CalculateExtension(Extension):
         self.parse_methods = {'calculate': self.parse_calculate,
                               'save': self.parse_save}
 
-        self.parameters_checker = None
-        self.new_parameters_set
+        self.parameters_processor._parameters_container = None
         self.environment = environment
 
     def parse(self, parser):
-        self.parameters_checker = None
         self.parser = parser
         self.stream = parser.stream
         tag_token = self.stream.current.value
@@ -605,19 +649,17 @@ class CalculateExtension(Extension):
 
     def check_parameter(self, parameter_name, parameter_value, context):
         parameters_object = context.parent['__parameters__']
-        if not self.parameters_checker:
-            template_type = context.parent['__template_type__']
-            chroot_path = context.parent['__datavars__'].main.cl_chroot_path
-            self.parameters_checker = TemplateParametersChecker(
-                                                        template_type,
-                                                        chroot_path=chroot_path
-                                                               )
-            parameters_object._new_template = True
-        elif not parameters_object._new_template:
-
-        print('pair = {0}: {1}'.format(parameter_name, parameter_value))
+        template_type = context.parent['__template_type__']
 
+        if self.parameters_processor._parameters_container is None:
+            self.parameters_processor.set_parameters_container(
+                                                             parameters_object)
 
+        self.parameters_processor.check_template_parameter(
+                                                    parameter_name,
+                                                    parameter_value,
+                                                    template_type,
+                                                    self.stream.current.lineno)
         return ''
 
     def get_condition_result(self):
@@ -642,9 +684,7 @@ class CalculateExtension(Extension):
                                              )
                 condition_list[-1] = condition_list[-1] + next_name
             else:
-                condition_list.append(
-                                         str(self.stream.current.value)
-                                     )
+                condition_list.append(str(self.stream.current.value))
             self.stream.skip(1)
 
         condition = ' '.join(condition_list)
@@ -695,7 +735,7 @@ class CalculateExtension(Extension):
 
     def save_parameters(cls, parameters_dictionary, context):
         '''Метод для сохранения значений параметров.'''
-        context.parent['__parameters__'].set_parameters(parameters_dictionary)
+        context.parent['__parameters__'].set_parameter(parameters_dictionary)
         return ''
 
 
@@ -711,18 +751,23 @@ def pkg(context, * args):
 class TemplateEngine:
     def __init__(self, directory_path='/',
                  datavars_module=Variables(),
-                 appends_set=set()):
-        TemplateParametersChecker._inspect_formats_package()
+                 appends_set=set(),
+                 chroot_path='/'):
+        ParametersProcessor._inspect_formats_package()
 
         CalculateExtension._parameters_set =\
-            TemplateParametersChecker.available_parameters
+            ParametersProcessor.available_parameters
         CalculateExtension._datavars = datavars_module
 
-        self.available_formats = TemplateParametersChecker.available_formats
-        self.available_appends = set()
+        self.available_formats = ParametersProcessor.available_formats
+        self.available_appends = appends_set
+        ParametersProcessor.available_appends = appends_set
 
-        self._datavars_module = datavars_module
         self._parameters_object = ParametersContainer()
+        self.parameters_processor = ParametersProcessor(chroot_path='/')
+        CalculateExtension.parameters_processor = self.parameters_processor
+
+        self._datavars_module = datavars_module
         self._template_text = ''
 
         self.environment = Environment(loader=FileSystemLoader(directory_path),
@@ -733,22 +778,36 @@ class TemplateEngine:
         '''Метод для смены директории в загрузчике.'''
         self.environment.loader = FileSystemLoader(directory_path)
 
-    def process_template(self, template_path, env=set()):
+    def process_template(self, template_path, template_type,
+                         parameters=None, env=set()):
         '''Метод для обработки файла шаблона, расположенного по указанному
         пути.'''
         CalculateContext._env_set = env
+
         template = self.environment.get_template(template_path)
-        self._parameters_object = ParametersContainer(parameters_dictionary={})
+
+        if parameters is not None:
+            self._parameters_object = parameters
+
+        self.parameters_processor._parameters_container = None
         self._template_text = template.render(
-                                         __datavars__=self._datavars_module,
-                                         __parameters__=self._parameters_object
+                                        __datavars__=self._datavars_module,
+                                        __parameters__=self._parameters_object,
+                                        __template_type__=template_type,
+                                        __DIR__=DIR, __FILE__=FILE
                                              )
 
-    def process_template_from_string(self, string, template_type, env=set()):
+    def process_template_from_string(self, string, template_type,
+                                     parameters=None, env=set()):
         '''Метод для обработки текста шаблона.'''
         CalculateContext._env_set = env
+
         template = self.environment.from_string(string)
-        self._parameters_object = ParametersContainer(parameters_dictionary={})
+
+        if parameters is not None:
+            self._parameters_object = parameters
+
+        self.parameters_processor._parameters_container = None
         self._template_text = template.render(
                                         __datavars__=self._datavars_module,
                                         __parameters__=self._parameters_object,
@@ -758,7 +817,7 @@ class TemplateEngine:
 
     @property
     def parameters(self):
-        return self._parameters_object.parameters
+        return self._parameters_object
 
     @property
     def template_text(self):

calculate/templates/template_processor.py

@@ -6,7 +6,7 @@ import stat
 import shutil
 from ..utils.files import join_paths
 from .template_engine import TemplateEngine, Variables, ConditionFailed,\
-                             TemplateParametersChecker, DIR, FILE,\
+                             ParametersProcessor, DIR, FILE,\
                              IncorrectParameter
 from ..utils.io_module import IOModule
 from collections import OrderedDict
@@ -67,7 +67,7 @@ class TemplateAction:
         self.target_path = target_path
 
         try:
-            self.template_parameters = TemplateParametersChecker(
+            self.template_parameters = ParametersProcessor(
                                                   parameters,
                                                   template_type=DIR,
                                                   chroot_path=self.chroot_path)
@@ -241,7 +241,7 @@ class TemplateAction:
         self.target_path = target_path
 
         try:
-            self.template_parameters = TemplateParametersChecker(
+            self.template_parameters = ParametersProcessor(
                                                   parameters,
                                                   template_type=FILE,
                                                   chroot_path=self.chroot_path)
@@ -440,21 +440,20 @@ class DirectoryProcessor:
     def __init__(self, action, datavars_module=Variables(), package='',
                  output_module=IOModule(), test_mode=False):
         self.action = action
-        self.chroot_path = datavars_module.main.cl_chroot_path
-        if not test_mode:
-            self.cl_chroot_path = datavars_module.main.cl_chroot_path
-        else:
-            self.cl_chroot_path = datavars_module.test.test_root
+        self.cl_chroot_path = datavars_module.main.cl_chroot_path
 
         self.datavars_module = datavars_module
         self.output = output_module
         self.template_action = TemplateAction(output_module=self.output,
-                                              chroot_path=self.chroot_path)
+                                              chroot_path=self.cl_chroot_path)
 
-        self.inheritable_parameters =\
-            set(TemplateParametersChecker.inheritable_parameters)
+        self.inheritable_parameters = set(
+                              ParametersProcessor.inheritable_parameters)
 
-        self.template_engine = TemplateEngine(datavars_module=datavars_module)
+        self.template_engine = TemplateEngine(
+                            datavars_module=datavars_module,
+                            chroot_path=self.cl_chroot_path,
+                            appends_set=self.template_action.available_appends)
         self.template_paths = (self.datavars_module.
                                main.cl_template_path.split(','))
 

calculate/utils/package.py

@@ -13,8 +13,13 @@ class PackageError(Exception):
     pass
 
 
+DEFAULT, NOTEXIST, NOTCORRECT, MULTIPLE = range(4)
+
+
 class PackageAtomError(Exception):
-    pass
+    def __init__(self, message='Package atom error', errno=DEFAULT):
+        self.message = message
+        self.errno = errno
 
 
 class PackageAtom:
@@ -45,7 +50,8 @@ class PackageAtom:
 
         if not parsing_result or parsing_result.string != package_atom:
             raise PackageAtomError("'package' parameter value '{}' is not"
-                                   " correct".format(package_atom))
+                                   " correct".format(package_atom),
+                                   errno=NOTCORRECT)
 
         if 'category' in parsing_result.groupdict():
             self._atom_dictionary['category'] = parsing_result.groupdict(
@@ -59,7 +65,6 @@ class PackageAtom:
         if ('slot' in parsing_result.groupdict() and
            parsing_result.groupdict()['slot'] and
            parsing_result.groupdict()['slot'] != ':'):
-            print('slot value is correct')
             self._atom_dictionary['slot'] = parsing_result.groupdict(
                                                                   )['slot'][1:]
         elif add_slot:
@@ -88,7 +93,8 @@ class PackageAtom:
             if not glob_result:
                 raise PackageAtomError("Package from 'package' parameter value"
                                        " '{}' does not exist".format(
-                                                            self.package_atom))
+                                                            self.package_atom),
+                                       errno=NOTEXIST)
             elif len(glob_result) == 1:
                 contents_path = next(iter(glob_result))
                 self._atom_dictionary['name'] = contents_path.split('/')[-2]
@@ -96,7 +102,8 @@ class PackageAtom:
             else:
                 raise PackageAtomError("'package' parameter value '{}' matches"
                                        " multiple installed packages".format(
-                                                            self.package_atom))
+                                                            self.package_atom),
+                                       errno=MULTIPLE)
 
     def _get_slot_value(self):
         contents_path = self._atom_dictionary['contents']

pytest.ini

@@ -28,4 +28,4 @@ markers =
     template_engine: marker for running tests for TemplateEngine.
     directory_processor: marker for running tests for DirectoryProcessor.
     template_action: marker for running tests for TemplateAction.
-    template_parameters: marker for running test for TemplateParameters.
+    parameters_processor: marker for running test for TemplateParameters.

run.py

@@ -11,12 +11,22 @@ main = Variables({'cl_template_path':
 datavars = Variables({'main': main})
 
 
-TemplateAction()
-template_engine = TemplateEngine(datavars_module=datavars)
-
-template_engine.process_template_from_string(
-         "{% calculate package = 'dev-lang/python-3.6', action = 'install' %}",
-         DIR)
-template_engine.process_template_from_string(
-         "{% calculate package = 'dev-lang/python-2.7', action = 'update' %}",
-         DIR)
+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))

tests/templates/test_template_action.py

@@ -1,7 +1,7 @@
 import pytest
 import os
-from calculate.templates.template_processor import TemplateAction,\
-                                                   TemplateParameters, DIR
+from calculate.templates.template_processor import TemplateAction, DIR
+from calculate.templates.template_engine import ParametersContainer
 
 
 template_action = TemplateAction()

tests/templates/test_template_parameters.py

@@ -1,34 +1,49 @@
 import pytest
 import os
-from calculate.templates.template_processor import TemplateParameters, DIR,\
-                                                   FILE, IncorrectParameter,\
-                                                   TemplateAction
+from calculate.templates.template_engine import ParametersProcessor, DIR,\
+                                                FILE, IncorrectParameter,\
+                                                ParametersContainer
+from calculate.templates.template_processor import TemplateAction
 from calculate.utils.files import join_paths
-from pprint import pprint
 
 
 CHROOT_PATH = os.path.join(os.getcwd(), 'tests/templates/testfiles')
 
 
-@pytest.mark.template_parameters
+parameters_processor = ParametersProcessor()
+parameters_processor.available_appends = TemplateAction().available_appends
+
+
+@pytest.mark.parameters_processor
 class TestTemplateParameters:
     def test_if_TemplateParameters_object_is_initialized_accoding_to_dictionary_of_correct_template_parameters__the_TemplateParameters_object_contains_processed_parameters_as_its_attributes_including_default_values(self):
         parameters = {'append': 'join',
                       'chmod': '600',
                       'force': True}
-        template_parameters = TemplateParameters(parameters, DIR)
-        assert (template_parameters.append == 'join' and
-                template_parameters.chmod == 0o600 and
-                template_parameters.force and
-                not template_parameters.autoupdate)
+
+        parameters_object = ParametersContainer()
+        parameters_processor.set_parameters_container(parameters_object)
+        for parameter_name, parameter_value in parameters.items():
+            parameters_processor.check_template_parameter(parameter_name,
+                                                          parameter_value,
+                                                          DIR, 1)
+
+        assert (parameters_object.append == 'join' and
+                parameters_object.chmod == 0o600 and
+                parameters_object.force and
+                not parameters_object.autoupdate)
 
     def test_if_TemplateParameters_object_is_intialized_using_dictionary_with_append_parameter__a_value_of_the_parameter_will_be_checked(self):
         parameters = {'append': 'join'}
-        # Для получения множества доступных значений параметра append.
-        TemplateAction()
+
+        parameters_object = ParametersContainer()
+        parameters_processor.set_parameters_container(parameters_object)
         try:
-            template_parameters = TemplateParameters(parameters, FILE)
-            assert template_parameters.append == 'join'
+            for parameter_name, parameter_value in parameters.items():
+                parameters_processor.check_template_parameter(parameter_name,
+                                                              parameter_value,
+                                                              FILE, 1)
+            assert parameters_object.append == 'join'
         except Exception as error:
             pytest.fail('Unexpected exception: {0}'.
                         format(str(error)))
@@ -36,72 +51,131 @@ class TestTemplateParameters:
     def test_if_TemplateParameters_object_is_intialized_using_dictionary_with_correct_source_parameter__the_object_will_be_initialized_successfully(self):
         parameters = {'source': '/test_dir_1/file.test'}
 
+        parameters_object = ParametersContainer()
+        parameters_processor.set_parameters_container(parameters_object)
+        parameters_processor.chroot_path = CHROOT_PATH
         try:
-            template_parameters = TemplateParameters(parameters, FILE,
-                                                     chroot_path=CHROOT_PATH)
-            assert template_parameters.source == join_paths(
+            for parameter_name, parameter_value in parameters.items():
+                parameters_processor.check_template_parameter(parameter_name,
+                                                              parameter_value,
+                                                              FILE, 1)
+            assert parameters_object.source == join_paths(
                                                        CHROOT_PATH,
                                                        '/test_dir_1/file.test')
         except Exception as error:
             pytest.fail('Unexpected exception: {0}'.
                         format(str(error)))
+        finally:
+            parameters_processor.chroot_path = '/'
+
 
     def test_if_TemplateParameters_object_is_intialized_as_dir_parameters_object_using_correct_source_parameter_with_append_link__the_object_will_be_initialized_successfully(self):
         parameters = {'append': 'link', 'source': '/test_dir_1'}
 
+        parameters_object = ParametersContainer()
+        parameters_processor.set_parameters_container(parameters_object)
+        parameters_processor.chroot_path = CHROOT_PATH
         try:
-            template_parameters = TemplateParameters(parameters, DIR,
-                                                     chroot_path=CHROOT_PATH)
-            assert template_parameters.source == join_paths(CHROOT_PATH,
-                                                            '/test_dir_1')
+            for parameter_name, parameter_value in parameters.items():
+                parameters_processor.check_template_parameter(parameter_name,
+                                                              parameter_value,
+                                                              DIR, 1)
+
+            assert parameters_processor.source == join_paths(CHROOT_PATH,
+                                                             '/test_dir_1')
         except Exception as error:
             pytest.fail('Unexpected exception: {0}'.
                         format(str(error)))
+        finally:
+            parameters_processor.chroot_path = '/'
 
     def test_if_TemplateParameters_object_is_intialized_using_source_parameter_with_unexisting_file_path__the_initialization_of_the_object_will_be_failed(self):
         parameters = {'source': '/test_dir_1/unexisted_file.test'}
+        parameters_object = ParametersContainer()
+        parameters_processor.set_parameters_container(parameters_object)
+
         with pytest.raises(IncorrectParameter):
-            template_parameters = TemplateParameters(parameters, FILE)
+            for parameter_name, parameter_value in parameters.items():
+                parameters_processor.check_template_parameter(parameter_name,
+                                                              parameter_value,
+                                                              DIR, 1)
 
     def test_if_TemplateParameters_object_is_intialized_as_dir_parameters_object_using_source_parameter_but_without_append_link__the_initialization_of_the_object_will_be_failed(self):
         parameters = {'source': '/test_dir_1/file.test'}
+        parameters_object = ParametersContainer()
+        parameters_processor.set_parameters_container(parameters_object)
+        parameters_processor.chroot_path = CHROOT_PATH
+
         with pytest.raises(IncorrectParameter):
-            template_parameters = TemplateParameters(parameters, DIR,
-                                                     chroot_path=CHROOT_PATH)
+            for parameter_name, parameter_value in parameters.items():
+                parameters_processor.check_template_parameter(parameter_name,
+                                                              parameter_value,
+                                                              DIR, 1)
 
     def test_if_TemplateParameters_object_is_intialized_using_dictionary_with_correct_force_parameter__the_object_will_be_initialized_successfully(self):
         parameters = {'force': True}
+        parameters_object = ParametersContainer()
+        parameters_processor.set_parameters_container(parameters_object)
+        parameters_processor.chroot_path = '/'
+
         try:
-            template_parameters = TemplateParameters(parameters, FILE)
-            assert template_parameters.force
+            for parameter_name, parameter_value in parameters.items():
+                parameters_processor.check_template_parameter(parameter_name,
+                                                              parameter_value,
+                                                              DIR, 1)
+            assert parameters_processor.force
         except Exception as error:
             pytest.fail('Unexpected exception: {0}'.
                         format(str(error)))
 
     def test_if_TemplateParameters_object_is_intialized_using_dictionary_with_incorrect_force_parameter__the_initialization_of_the_object_will_be_failed(self):
         parameters = {'force': 'value'}
+        parameters_object = ParametersContainer()
+        parameters_processor.set_parameters_container(parameters_object)
+
         with pytest.raises(IncorrectParameter):
-            template_parameters = TemplateParameters(parameters, FILE)
+            for parameter_name, parameter_value in parameters.items():
+                parameters_processor.check_template_parameter(parameter_name,
+                                                              parameter_value,
+                                                              FILE, 1)
 
     def test_if_TemplateParameters_object_is_intialized_using_dictionary_with_autoupdate_parameter__a_value_of_the_parameter_will_be_checked(self):
         parameters = {'autoupdate': True}
+        parameters_object = ParametersContainer()
+        parameters_processor.set_parameters_container(parameters_object)
+
         try:
-            template_parameters = TemplateParameters(parameters, FILE)
-            assert template_parameters.autoupdate
+            for parameter_name, parameter_value in parameters.items():
+                parameters_processor.check_template_parameter(parameter_name,
+                                                              parameter_value,
+                                                              FILE, 1)
+            assert parameters_processor.autoupdate
         except Exception as error:
             pytest.fail('Unexpected exception: {0}'.
                         format(str(error)))
 
     def test_if_TemplateParameters_object_is_intialized_using_dictionary_with_incorrect_autoupdate_parameter__the_initialization_of_the_object_will_be_failed(self):
         parameters = {'autoupdate': 'value'}
+        parameters_object = ParametersContainer()
+        parameters_processor.set_parameters_container(parameters_object)
+
         with pytest.raises(IncorrectParameter):
-            template_parameters = TemplateParameters(parameters, FILE)
+            for parameter_name, parameter_value in parameters.items():
+                parameters_processor.check_template_parameter(parameter_name,
+                                                              parameter_value,
+                                                              FILE, 1)
 
     def test_if_TemplateParameters_object_is_intialized_using_dictionary_with_correct_chown_parameter__the_object_will_be_initialized_successfully(self):
         parameters = {'chown': 'root:root'}
+        parameters_object = ParametersContainer()
+        parameters_processor.set_parameters_container(parameters_object)
+
         try:
-            template_parameters = TemplateParameters(parameters, FILE)
-            assert template_parameters.chown == {'uid': 0, 'gid': 0}
+            for parameter_name, parameter_value in parameters.items():
+                parameters_processor.check_template_parameter(parameter_name,
+                                                              parameter_value,
+                                                              FILE, 1)
+            assert parameters_processor.chown == {'uid': 0, 'gid': 0}
         except Exception as error:
             pytest.fail('Unexpected exception: {0}'.
                         format(str(error)))
@@ -110,28 +184,56 @@ class TestTemplateParameters:
         uid = os.getuid()
         gid = os.getgid()
         parameters = {'chown': '{0}:{1}'.format(uid, gid)}
+        parameters_object = ParametersContainer()
+        parameters_processor.set_parameters_container(parameters_object)
+
         try:
-            template_parameters = TemplateParameters(parameters, FILE)
-            assert template_parameters.chown == {'uid': uid, 'gid': gid}
+            for parameter_name, parameter_value in parameters.items():
+                parameters_processor.check_template_parameter(parameter_name,
+                                                              parameter_value,
+                                                              FILE, 1)
+            assert parameters_processor.chown == {'uid': uid, 'gid': gid}
         except Exception as error:
             pytest.fail('Unexpected exception: {0}'.
                         format(str(error)))
 
     def test_if_TemplateParameters_object_is_intialized_using_dictionary_with_incorrect_chown_parameter__the_initialization_of_the_object_will_be_failed(self):
         parameters = {'chown': 'wrong_user_name:wrong_group_name'}
+        parameters_object = ParametersContainer()
+        parameters_processor.set_parameters_container(parameters_object)
+
         with pytest.raises(IncorrectParameter):
-            template_parameters = TemplateParameters(parameters, FILE)
+            for parameter_name, parameter_value in parameters.items():
+                parameters_processor.check_template_parameter(parameter_name,
+                                                              parameter_value,
+                                                              FILE, 1)
 
     def test_if_TemplateParameters_object_is_intialized_using_dictionary_with_correct_chmod_parameter__the_object_will_be_initialized_successfully(self):
+        parameters = {'chmod': 'rw-r--r--'}
+        parameters_object = ParametersContainer()
+        parameters_processor.set_parameters_container(parameters_object)
+
+        try:
+            for parameter_name, parameter_value in parameters.items():
+                parameters_processor.check_template_parameter(parameter_name,
+                                                              parameter_value,
+                                                              FILE, 1)
+            assert parameters_processor.chmod == 0o644
+        except Exception as error:
+            pytest.fail('Unexpected exception: {0}'.
+                        format(str(error)))
+
+    def test_if_TemplateParameters_object_is_intialized_using_dictionary_with_correct_chmod_parameter_in_its_digital_form__the_object_will_be_initialized_successfully(self):
+        parameters = {'chmod': '600'}
+        parameters_object = ParametersContainer()
+        parameters_processor.set_parameters_container(parameters_object)
+
         try:
-            parameters = {'chmod': 'rw-r--r--'}
-            template_parameters = TemplateParameters(parameters, FILE)
-            assert template_parameters.chmod == 0o644
-            del(template_parameters)
-
-            parameters = {'chmod': '600'}
-            template_parameters = TemplateParameters(parameters, FILE)
-            assert template_parameters.chmod == 0o600
+            for parameter_name, parameter_value in parameters.items():
+                parameters_processor.check_template_parameter(parameter_name,
+                                                              parameter_value,
+                                                              FILE, 1)
+            assert parameters_processor.chmod == 0o600
         except Exception as error:
             pytest.fail('Unexpected exception: {0}'.
                         format(str(error)))