From 476d59201ff83634e628cf1e06a5073338455205 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=98=D0=B2=D0=B0=D0=BD=D0=BE=D0=B2=20=D0=94=D0=B5=D0=BD?= =?UTF-8?q?=D0=B8=D1=81?= Date: Tue, 28 Apr 2020 18:45:45 +0300 Subject: [PATCH] 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 | 127 ++++++----- calculate/utils/package.py | 279 +++++++++++++++++++++--- run.py | 48 ++-- tests/templates/test_template_engine.py | 70 +++--- 4 files changed, 392 insertions(+), 132 deletions(-) diff --git a/calculate/templates/template_engine.py b/calculate/templates/template_engine.py index 744a46d..c23c6e1 100644 --- a/calculate/templates/template_engine.py +++ b/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 ''.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 ''.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 diff --git a/calculate/utils/package.py b/calculate/utils/package.py index 60a1d1d..96bb7da 100644 --- a/calculate/utils/package.py +++ b/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 ''.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[^\s/]*)/ - (?P[^\s:]*) - (?P:\S*)? - (?P(?:\s+\S*)*) - ''', re.VERBOSE) + (?P[^\s\-:]*) + (?P-\d[^\s:]*)? + (?P:[^\s\[]*)?\s* + (?P\[\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(' ') diff --git a/run.py b/run.py index af0b9be..647a6b1 100644 --- a/run.py +++ b/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)) diff --git a/tests/templates/test_template_engine.py b/tests/templates/test_template_engine.py index 566b4e3..5509d21 100644 --- a/tests/templates/test_template_engine.py +++ b/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